ATARI
8 PROGRAMMING
O
Concepts and Techniques
8
w
3
c
3
/ ?////* / / 1 1 jjp
A Data Becker book published by
m ■ v#u c,n cm "‘ ob ffffffiium r*
Abacus mm Software
;ii **>♦♦♦♦«
3-D Graphic
programming
By Uwe Braun
A Data Becker Book
Published by
A I I lMWSIIlj) r c -
Abacus iiiiiiisnl Software
First Printing, Aug. 1986
Printed in U.S.A.
Copyright © 1985 Data Becker GmbH
Merowingerstr.30
4000 Dusseldorf, West Germany
Copyright © 1985 Abacus Software, Inc.
P.O.Box 7219
Grand Rapids, MI 49510
This book is copyrighted. No part of this book may be reproduced, stored
in a retrieval system, or transmitted in any form or by any means,
electronic, mechanical, photocopying, recording or otherwise without the
prior written permission of Abacus Software or Data Becker, GmbH.
Every effort has been made to insure complete and accurate information
concerning the material presented in this book. However Abacus Software
can neither guarantee nor be held legally responsible for any mistakes in
printing or faulty instructions contained in this book. The authors will
always appreciate receiving notice of subsequent mistakes.
ATARI, 520ST, ST, TOS, ST BASIC and ST LOGO are trademarks or
registered trademarks of Atari Corp.
GEM is a registered trademark of Digital Research Inc.
ISBN
0 - 916439 - 69-0
Table of Contents
1. Introduction 3
2. Mathematical Basis of Graphic Programming 7
2.1 Moving the Coordinate Base 10
2.1.1 Scaling the Axis 12
2.1.2 Rotation around one point 16
2.2 Plane conversion with matrix operations 19
2.3 Clipping 26
2.4 Transformations in three dimensional space 40
2.4.1 Rotation about any desired axis 36
2.5 Projection from space to a two dimensional plane 43
2.6 Perspective transformation 48
2.7 Hidden lines and hidden surfaces 56
2.8 Rembrandt and hidden surfaces 65
3. Machine language fundamentals for graphic
programming 75
3.1 Speed Advantages from tables 76
3.2 Assembler routines for screen manipulation 79
3.2.1 Drawing lines 80
3.3 Operating system functions 87
3.3.1 Starting a program 88
4.
Graphics using assembly language routines
107
4.1
Definition of a data structure of an object in
space
108
4.1.1
Explanation of subroutines used
152
4.1.2
Description of the Subroutines of the first
Main program
165
4.2
Generation techniques for creating rotating
objects
169
4.1.2
New subroutines in this program
188
4.3
Hidden line algorithm for convex bodies
191
4.3.1
Explanation of the newly added subroutines
214
4.3.1.1
Errors with non-convex bodies
215
4.4
The painter algorithm
216
4.4.1
New things in the main program rotl.s
246
4.4.2
Sort algorithm
247
4.5
Entering rotation lines with the mouse
248
4.5.1
Description of the new subroutines
296
4.6
Handling several objects
298
5.
Suggestions for additional development
327
5.1
Light and Shadow
329
5.2
Animated Cartoons
330
Appendices
A
Number systems
333
B
Analytical geometry of the planes and space
335
B.l
Scalar product
342
B.2
Cross product
342
C
Matrix calculations
344
C.l
Adding matrices
345
C.2
Multiplying matrices
346
D
Bibliography
348
Index
349
L_
Abacus Software
ST 3D Graphics
1. Introduction
The possibilities of computer graphics are some of the most challenging
reasons for working with a computer today. Dazzling computer-generated
images are showing up almost everywhere--in medicine, engineering,
motion pictures, music videos, television advertising, and even in
newspapers like USA Today. The public is fascinated by the unlimited
forms that computer graphics are taking. Some of the more sophisticated
of these works are the three-dimensional, computer-animated videos used
in television advertisements.
One major application of computer graphics in industry is for CAD
(Computer-Aided Design) systems. The integration of CAD systems into
the manufacturing process is of increasing importance. Known as CAD-
CAM (Computer-Aided Design - Computer-Aided Manufacturing), these
systems are making significant inroads in automating many of the
manufactured, assembled, and processed goods such as machine tools,
automobiles, electronics, and agricultural products. Without advanced
graphic data processing, the latest medical processes such as CAT scans
would be difficult, if not impossible. Furthermore, three-dimensional
graphic data processing has made it possible to visually represent
complicated scientific relationships and to make them comprehensible
(like atomic and molecular models and the DNA helix). Eventually these
graphics will be integrated with advanced teaching and simulation
methods, and are bound to have a profound impact on the way we think
and learn.
The enormous strides made in the production of integrated circuits and
the increase in processing speeds of relatively new microprocessors such
as the Motorola MC68000 has made it possible for the home and personal
computers to enter application areas that were formerly the domain of
large mainframe computers costing several hundred thousand dollars.
Even now, an affordable 32-bit personal computer is just around the
comer. The traditional distinctions between microcomputers,
minicomputers, and mainframes are becoming increasingly blurred.
Of course, even the largest mainframes are getting faster as well. The
fastest computer at this time, the Cray II, has a throughput capacity of
2000 megaflops (200 million floating-point operations per second). Such
high computing speeds are needed to closely simulate natural world
processes with computer models. Examples are the simulation of
3
ST 3D Graphics
Abacus Software
ecological problems (acid rain), simulation of the human physiology,
weather prediction, nuclear fusion and fission, origin of the solar system,
simulation of star systems, space travel, etc.
This book is intended to explore some of the possibilities of creating two-
and three-dimensional computer graphics on the Atari ST computer
series. To obtain a good understanding of the program sections, you
should have some fundamental knowledge of MC68000 machine
language.
Machine language represents the lowest level of communication with the
computer and contains a small number of rather simple instructions that
are consequently easy to learn. For the hobbyist, knowing machine
language programming makes it easier to understand the data structure of
higher-level languages such as Pascal and C. However, most problems
and algorithms are easier to program in a higher-level language than in
machine language.
For the problem of depicting and representing the 3-D wire models
presented here, maximum processor speed is crucial. Machine language is
clearly superior to any higher-level language in fulfilling this
requirement. With these applications for the Atari ST, real-time three-
dimensional graphics can be achieved. The removal of hidden lines and
the shading of areas requires a considerable amount of processor time.
The Cray II requires 8 minutes to create a single picture with a resolution
of 2000 by 3000 pixels, with up to 30 bits of color information per picture
point. In contrast, the ST manages only 640 by 400 pixels and only one
bit of color information. Of course, it is possible to increase the
computational capabilities of the ST with programming tricks, fast mass
storage (hard disk) and large amounts of memory to solve more complex
graphic problems.
This book provides you with help in solving the complex programming
problems of three-dimensional graphics. While the sample programs are
directly tailored for the Atari ST, the techniques can be used without too
much difficulty on other computers. Only the routines for hardware
communication and display control (keyboard input, line drawing, surface
shading (if possible) and switching between two screens) need to be
tailored to another computer using an MC68000 CPU (i.e., the Apple
Macintosh and Commodore’s Amiga). The subroutines for generating
and handling three-dimensional graphic objects can be run on any
computer with an MC68000 microprocessor.
4
Abacus Software
ST 3D Graphics
2. Mathematical Basis of Graphic Programming
This chapter serves as the mathematical foundation of computer¬
generated, three-dimensional graphics. As a result, the explanations are
very extensive. For this reason we ask readers who are already familiar
with these topics for a little patience and understanding.
All computer graphic problems can ultimately be reduced to the problem
of drawing points on a graphic output device (monitor screen, plotter, or
printer) and to connect these points with lines. There may also be the task
of shading the area delineated by the lines. For a demonstration, we will
use a two-dimensional plane with one Cartesian coordinate system,
familiar to everybody, whose origin lies in the lower left hand comer of
the screen.
Cartesian coordinate system
T - 1 - 1 - 1 - 1 -r— i r r i i r»
I ST display coordinate system
Fig. 2.1: coordinate system and ST display coordinate system
In Figure 2.1, the first problem of representing graphics becomes clear.
The Cartesian coordinate system and the display coordinate system used
by the ST’s software and hardware are not the same. The directions of the
y-axis are opposite, and the coordinate origin is displaced. Consequently,
7
ST 3D Graphics
Abacus Software
an object defined in the first system is inverted in the system on the right,
and is also displaced on the y-axis.
At first, you might be tempted to define objects to be represented using
the ST’s coordinate system. But doing this does not solve the second
problem-that the display surface of every computer is limited. The ST
can display only 640x400 points at its highest resolution. So, to avoid
defining objects with these limitations of 640x400 points, we must be
able to define an object in any desired coordinate system before
displaying it on the monitor screen. In other words, we must be able to
scale the object in any of the coordinate systems, i.e., change its size. All
points of the defined object can then be transformed using graphics
operations.
This operation is called windowing. We now introduce three coordinate
systems. They are:
1. world coordinate system
2. view coordinate system
3. picture coordinate system
Individual objects are defined in the world coordinate system , where the
calibration of the coordinate axis may be any desired unit of
measurement—for example, millimeters, kilometers, years, etc.
The view coordinate system accepts a portion of the world coordinate
system. This is similar to an observation window in the world coordinate
system.
Finally, the picture coordinate system represents the physical screen
display of the computer, A single point in this system corresponds to an
individual pixel on the screen.
This concept can be explained very simply with an example. Two objects
are defined in a world coordinate system, the outlines of a house and of a
church. The two outlines represent all objects that can be depicted on a
plane. For example, an architect would use the outline of the house in a
world coordinate system to define individual rooms and furniture.
Abacus Software
ST 3D Graphics
Our task is to transform the observation window, together with the house
that fills its surface, to the specific picture window for display on the ST’s
screen.
Here’s the preferred solution to the problem, using the view coordinate
system: The origin of the world coordinate system is moved to the lower
left comer of the observation window and scaled by a suitable factor. It
now represents all points in the picture coordinate system. If the points
are in the field of picture coordinates, they can be drawn and connected
with lines.
Cartesian coordinate system Screen system for Atan ST
Fig. 2.2: Transformation of world coordinates to picture coordinates
9
ST 3D Graphics
Abacus Software
2.1 Moving the coordinate base
Scaling and (as we shall see later) rotation are both related to the
coordinate base. To scale an object in relation to another point, or to
rotate it around an arbitrary point, the coordinate origin must first be
moved to the relative origin. We can illustrate this again using the house
example.
nx
Fig. 2.1.1
One way to describe the house is to list the coordinates of the end points
and to list the points which are connected with lines. For this example,
the two lists are as follows:
10
Abacus Software
ST 3D Graphics
End point list:
Point
X-coordinate
Y-coordinate
PI
100
50
P2
100
90
P3
120
130
P4
140
90
P5
140
50
Connection list:
Line from
Point A to
Point B
LI:
PI
P2
L2 :
P2
P3
L3:
P3
P4
L4 :
P4
P5
L5:
P5
PI
This description of a polygon, consists of a sequence of closed lines. It
contains all the information necessary for representing it on the display
screen. To draw the polygon, the lines’ endpoints are passed to a
subroutine for drawing.
As we shall see later, the polygon is also perfectly acceptable for the
description of complex, three-dimensional objects. Any physical object
can be closely approximated by chaining various polygons. Also, natural
asymmetrical bodies such as mountains, forests, lakes and animals can be
represented in a realistic manner with polygons created through fractional
geometry, i.e. fractals. In addition, most man-made objects are
constructed in a symmetrical manner and are easier to represent
graphically.
In Figure 2.1.1 the coordinate origin of the world system is moved to
point P1 [ 10 0,5 0 ] . The new world coordinates (view coordinates) are
obtained by subtracting the coordinates of point P1— the new origin—from
the points that define the object. In general, the new world coordinates
are equal to the old world coordinates, minus the coordinates of the new
origin (in world coordinates). If we describe the old world coordinate axis
with x and y, the new world coordinate axis with x' and y', the new
origin point with NU[nx,ny3 and the point to be moved with
P1 [ x, y ], we can write:
Pl[xl',yl'] = Pl[xl,yl] - NU[nx,ny]
11
ST 3D Graphics
Abacus Software
For example, for point 5—the new origin is located at
PI (100,50) = NU (100,50). The coordinates of the point to be
moved P 5 (14 0,5 0) become in the new world coordinate system
P5x' =140-100 = 40, P5y' =50-50 = 0. The point
P5 (140,50) becomes point P5' (40,0) . This translation must be
performed for every point of the object. It is possible to move the origin
of the world coordinate system to any point.
2.1.1 Scaling the Axis
As previously mentioned, scaling the axis refers to the coordinate origin.
This can be readily seen in Figure 2.1.2. The points of the house, i.e. the
X and Y coordinates, are scaled by the factor one half in the X and Y
axes. The result is the halving of the length of the edges, but also a
translation in the direction of the origin. If we want to avoid displacing
the direction of the origin, then before scaling the origin must be moved
to a point not affected by the scaling itself. The Figure 2.1.3 is an
example. If we want to leave the left lower comer of the house (the point
PI) in its place. The origin is moved to point PI. The picture is scaled by
multiplying the X and Y values by one half and finally moving the origin
to its original location. In this example this means:
1. Subtract 100 from the X-values of points P1-P5
Subtract 50 from the Y-values of points P1-P5
2. Multiply all X- and Y-values of points P1 -P 5
with the factor one half.
3. Add 100 to all X-values of points P1-P5
Add 50 to all Y-values of points P1-P5
12
Abacus Software
ST 3D Graphics
13
ST 3D Graphics
Abacus Software
Figure 2.1.3
Scaling with factors greater than one enlarges the object. If we select
different scaling factors for the X and Y axes, a distorted picture of the
object results.
At this point let’s briefly return to the example, at Figure 2.1, and alter
the scaling factors for converting to view coordinates. With the maximum
coordinates of the observation:
[wxmin,wymin]; [wxmax,wymax],
and the display window
[vxmin,vymin]; [vxmax,vymax]
one can give differing scaling factors for the two axes, Sx and Sy. In our
example:
Sx=(vxmax-vxmin)/(wxmax-wxmin)
Sy=(vymax-vymin)/(wymax-wymin)
14
Abacus Software
ST 3D Graphics
Before scaling, the origin of the world system is moved to the left lower
comer of the observation window [wxmin, wymin], since this point is
the data point of the scaling. The result of the conversions is therefore:
1. Move the origin to the point W1 [wxmin,wymin] by
subtracting wxmin from all of the X coordinates and
wymin from all of the Y coordinates.
2. Multiply all X and Y values of the points with the factor j
Sx. If the relationship of height to width is equal for hpth c <»•/*'' ‘ oa «UL
windows, then Sx=Sy. A*}*^ xV r °°
3. Convert to the display system by multiplying the Y values
by -I and adding of the maximum Y value to these Y
values (for the monochrome ST this is 399). This moves
the origin to the upper left comer of the screen.
The third step of converting the Y values to the screen display of the ST
is always the same. During the description we shall limit ourselves to the
view system. If during subsequent discussions no special reference is
made to this step, you should remember that if it is not performed, all
objects appear inverted on the screen after the drawing is completed.
The location of the picture window in the view system is not fixed to the
origin, but is movable in the total view system. However, the three
conversions must be followed by another conversion-moving the
window to point VI [vxmin,vymin] . Basically the conversion of an
object is the opposite of the conversion of a coordinate system. Therefore,
when moving the picture window and the object to the point
VI [vxmin, vymin] , the coordinates of this point (vxmin and
vymin) must be added to all object coordinates.
Summarizing the conversion of the world system into the view system:
1. Move the origin to the point W1 [wxmin,wymin] by
subtracting wxmin from all X coordinates, and wymin
from all Y coordinates.
2. Multiply all X values of the points by the factor
Sx=(vxmax-vxmin)/(wxmax-wxmin) , the Y
values with the factor Sy= (vymax-vymin) / (wymax-
wymin) .
15
ST 3D Graphics
Abacus Software
3. Move the window and the object to the point
VI [vxmin, vymin] by adding vxmin to all X values,
and vymin to all Y values.
4. Convert to the display system by multiplying the Y values
by -1 and adding the maximum Y-value to these Y values
(for the highest resolution this value is always 399).
2.1.2 Rotation around one point
The rotation of an object is related to a single point, just as we found out
in the previous section on scaling. To start the conversion, a single point
is rotated around the origin. Since the rotation occurs around the single
origin point, the data point of the rotation angle is the connecting line
between coordinate source and the point to be rotated. See Figure 2.1.4.
The point PI (xl,yl) is moved by rotation around the angle p of the
origin to the point P2 (x2,y2). We must define the sign of the angles a
and p as + or Following the conventions of mathematics, we designate
16
Abacus Software
ST 3D Graphics
the angles as positive when the rotation moves the positive X axis to the
positive Y axis. Expressed differently, positive angles are measured in the
counterclockwise direction. For the angle between the connecting line
from 0,0 to P1 and the X-axis, the relationships are:
1) SIN(alpha) = Yl/C
2) COS(alpha) = Xl/C
3) SIN (alpha+beta)=Y2/C
4) COS(alpha+beta)=X2/C
with C=V (X1 2 +Y1 2 ) W (X2 5 +Y2 2 ) . The addition theorems for the
angle functions SIN and COS are as follow (we won’t derive them here):
5) SIN(Alpha+Beta)=SIN(Alpha)*COS
(Beta)+COS(Alpha)*SIN(Beta)
6) COS(Alpha+Beta)=COS(Alpha)*COS(Beta)-
SIN(Alpha)*SIN(Beta)
By combining these equations, X2 and Y2 can be calculated quite easily:
7) X2/C=COS(Alpha)*C0S(Beta)-
SIN(Alpha)*SIN(Beta)
gives us
8) X2= COS(Alpha)*C* COS (Beta) -
SIN(Alpha)*C* SIN(Beta)
from 1) follows
9) X2=Xl*COS(Beta)-Y1*SIN(Beta)
10) Y2=Yl*COS(Beta)+X1*SIN (Beta)
17
ST 3D Graphics
Abacus Software
As an example of rotation, we will rotate the house in Figure 2.1.5 by an
angle of 30 degrees around the origin. The points P1-P5 become points
R1-R5, as can be seen on the example at Point PI.
R1X=P1X*C0S (30)-P1Y*SIN(30)
R1Y=P1Y*COS(30)+P1X*SIN (30)
From PI (100,50) follows R1 (61. 6,93.3). According to the same
principle, the remaining points are likewise converted.
Figure 2.1.5
18
Abacus Software
ST 3D Graphics
2.2 Plane conversion with matrix operations
After learning about the conversions, translations, scaling and rotations
described in the previous chapter, we are now able to draw on the screen
any object previously defined in a two dimensional coordinate system, in
any selected size and viewing angle. One drawback to this method is that
several arithmetic operations are required for each and every point of the
object.
Right now we’ll combine these conversion operations into a single matrix
operation. (Explanations of matrix operations are found in the Appendix).
Therefore it becomes possible to apply the conversions to the array and
then to multiply the resulting array with every point of the object. To
make the array operations usable for the point coordinates of the plane,
the point coordinates are first converted to array form.
There are basically two ways to convert these: with column vectors (2,1),
or with line vector (1,2) arrays. A conversion array (2,2) is used to
multiply a line vector with the transformation array, where the
transformation array must be multiplied with the column vector, (number
of columns A = number of rows B).
In this book we shall write the point coordinates as line vectors P and the
multiply this line vector with the transformation array. This sequence of
multiplication simplifies, purely subjectively, the creation of the
transformation matrices. If you multiply a line vector (1,2) with a
quadratic array (2,2), you will obtain as a result another line vector (1,2),
which represents point coordinates. The individual point operations can
be expressed by a suitable transformation matrix T. For scaling the X axis
by the factor 2, the array S1 is valid. It is also possible to quadruple the Y
values using transformation array S2. The two scaling steps can be by
multiplying SI and S2 with array S3.
Si 2 0
0 1
S2 = 1 0
0 4
S 3 = S 1 * S 2 = 2 0
0 1
★
1 0
0 4
s 3
0
4
19
ST 3D Graphics
Abacus Software
For rotation, R x is valid for one counter clockwise rotation; from
trigonometry, a clockwise rotation occurs with r 2 . From Figure 2.1.5, the
movement of point P1 [ x 1, y 1 ] to point P2[x2,y2], results from
multiplying P1 with R.
Rl = cos(b)
-sin(b)
sin(b)
cos(b)
R -2 = cos(-b)
sin(-b)
= cos(b)
-sin(b)
-sin {-b
cos(-b)
sin(b)
cos(b)
P2[X2,Y2] = [XI,
Yl] *
cos (30)
sin(30)
-sin(30)
cos (30)
Several rotations in succession can be carried out by multiplying the
rotation matrices. Unfortunately, this array form does not permit
translation (origin relocation). For this you can add a dimension to the
vectors. Every n-dimensional object can be represented in a (n+1) space
in innumerable many ways.
In a three dimensional space there are infinite possibilities for laying out
the X-Y plane we have just observed. The additional dimension is known
as Z coordinate of the X-Y plane. For two dimensional objects, its value
is always one. The X and Y coordinates remain unchanged: the line
vector [x,y] becomes the line vector [x,y,l]. The array for the translation
of the source at point D is as follows:
110
T = 0 10
-DX -DY 1
Every point of the object must be multiplied with this array to move the
origin of the world coordinate system to the point (DX, DY). For the point
P [ x, y, 1 ] the result is: new point in world coordinates p' =p*T
10 0
P'[x',y',l] = [x,y,1] *010= [x-dx,y-dy,1]
-DX -DY 1
20
Abacus Software
ST 3D Graphics
You can combine two displacements by using array multiplications. First
the origin is moved to the point [DX,DY, 1 ] and then to the point
[AX, AY, 1 ] of the new coordinate system. The two translation matrices
Tl and T2 are as follows:
10 0 10 0
T 1 =010 T 2 =010
DX -DY 1 -AX -AY 1
Multiplication of the matrices results in T 3 :
10 0 10 0
t 3 =t 1 *t 2 = 0 1 0 * 0 1 0
-DX -DY 1 -AX -AY 1
10 0
T 3 = 0 1 0
-DX-AX -DY-AY 1
P'[x',y',l]= P[x,y,1]*T 3 = [x-DX-AX,Y-DY-AY,1]
The scaling array S can be defined in the new system:
SX 0 0
S = 0 SY 0 and P' = P * S
0 0 1
and finally the rotation array R
cos (a) sin (a) 0
R(a) = -sin(a) cos (a) 0
0 0 1
21
ST 3D Graphics
Abacus Software
Scaling as well as rotation, viewed individually, may be carried out in a
series through array multiplications. The array multiplication is normally
not commutative, i.e. Ti * T 2 is not necessarily identical with T 2 * Ti.
However, the multiplication of the following array types is commutative:
1)
Translation
*
Translation
2)
Scaling
*
Scaling
3)
Rotation
*
Rotation around
the same axis
4)
Scaling
•k
Rotating
Type 4 (scaling and rotating) is only valid when both scale factors
(Sx, Sy) are identical.
These fundamentals enable us, through a combination of several array
operations, to rotate an object around a selected point V[vx,vy,l]
using a series of several array operations. The various operations are:
1. Shifting the origin to point V
2. Rotation around point V by an angle of alpha
3. Shifting of the origin to the original point
Three matrices T x , R x and T 2 are required:
l
0
0
co3(a)
sin(a)
0
Ti -
0
1
0
Rl =
-sin (a)
cos(a)
0
-vx
-vy
1
0
0
1
1
0
0
t 2 =
0
1
0
vx
vy
1
For the multiplication array M 1# the result is:
Mi = T x * Ri * T 2 and for every point follows:
P' = P * Mi
22
Abacus Software
ST 3D Graphics
The sequence of matrices is decisive in these operations and must occur
from left to right. It is possible however, to first calculate intermediate
results, but these must be used in the "right" sequence. In this example,
there are two possible ways to proceed:
1. First calculate from Z i =T 1 *R 1 and then M 1 =Z 1 *T 2
2. First calculate from Z 2 =Ri*T 2 and then M 2 =T 1 *Z 2
The first case is explained in detail. Z 1 =T 1 *R 1 :
0 0
cos(a)
sin(a) 0
1 0 *
-sin(a)
cos (a) 0
-vy 1
0
0 1
cos (a)
sin(a)
0
-sin(a)
cos(a)
0
cos(a)+vy*sin(a)
-vx*sin(a)-vy*cos(a)
1
and now M i =z 1 *T 2 :
cos(a) sin(a)
M x = -sin(a) cos(a)
-vx*cos(a)+vy*sin(a) -vx*sin(a)-vy*cos(a)
0
0 *
1
10 0
0 1 0 =
vx vy 1
sin(a) 0
cos(a) 0
vx*sin(a)-vy*cos(a)+vy 1
cos(a)
-sin(a)
-vx*cos(a)+vy*sin(a)+vx
23
ST 3D Graphics
Abacus Software
If point PI [x, y, 1 ] is multiplied with this array, the result is point
PI' [x' , y' , 1], the point PI which was rotated around the angle
alpha at point VI [vx, vy, 1]. This connection can be recognized in
Figure 2.2.1 and should be performed as example for point PI.
PI [x, y, 1 ] * Ml =
cos (a) sin (a) 0
[x,y,l] * -sin (a) cos (a) 0
—vx*cos(a)+vy*sin(a)+vx -vx*sin(a)-vy*cos(a)+vy 1
Pl[x,y,z]= f[x*cos(a)-y*sin(a) -vx*cos (a) +vy*sin (a) +vx] ,
[x*sin(a)+y*cos(a)-vx*sin(a)-vy*cos(a) +vy], [1] ]
You can see that when the rotation point and the point to be rotated are
identical, therefore x=vx and y=vy, the expression for the line vector of
the point at [ vx, vy, 1 ] = [ x, y, 1 ] degenerates. That means that the
point coordinates do not change.
24
Abacus Software
ST 3D Graphics
The house already familiar in Figure 2.2.1 shall be rotated by the angle
alpha=30 degrees around the point VI [ vx, vy, 1 ] = [ 12 0,8 0, 1 ]. As
an example this is carried out on point P2[100,90,l].
P2x'=100*cos(30)-90*sin(30)-120*cos(30)+80*sin(a)+120
P2y'=100*sin(30)+90*cos(30)-120*sin(30)-80*cos (30)+80
P2'=[97.68,78.66,l] and finally for the remaining points P1-P5.
PI'=[117.68,44.02,1]
P2'=[97.68,78.66,1]
P3'=[95,123.30,1]
P4'=[132,32,98,66,l]
P5'=[143.66,59.02,1]
This procedure also permits you to change the point for scaling to any
location in the coordinate system. In the following, you can see the
buildup of the transformation array. First the coordinate origin is moved
to point K1 [ kx,ky,1] with translation array T 1? then scaling with array
Si, using scaling factor Sx and Sy, and finally moving the origin to its
original location using translation array T 2 . For every single point this
means p' [x' ,y', 1] = p [x,y, 1] *T 1 *S 1 *T 2 .
-kx
0 0
1 0
-ky 1
Sx
Si- 0
0
0 0
Sy 0
0 1
1
t 2 = 0
kx
0 0
1 0
ky 1
Sx 0 0
T-l* Si* T 2 = 0 Sy 0
kx*(l-Sx) ky*(1-Sy) 1
P'[x,y,1] =P'[x*Sx+kx(1-Sx),y*Sy+ky(1-Sy),1]
In this example Sx=Sy=0.5.
25
ST 3D Graphics
Abacus Software
2.3 Clipping
As we transformed the object coordinates to the display coordinate
system, we assumed that all points in the object can be represented in the
picture coordinate system. When we define a window in the world
system, some objects may be completely pushed out of the view of the
window, or objects are cut in half by the window. This means that one or
several connecting lines of the points cut the comers of the observation
window.
Figure 2.3.1
To avoid these incomplete objects, we can test the coordinates to make
sure they lie within the borders of the window. This method slows down
the drawing procedures considerably. Therefore it is better to determine
before drawing a line if the line is completely visible, partially visible, or
not visible at all. The window is surrounded by eight equally large
surfaces to determine the exact position of the line to the window. Now
the exact location of a line can be determined by comparing its
26
Abacus Software
ST 3D Graphics
coordinates to the window borders. A code containing four bits can be
used to represent the relative position of a line outside of the window.
Bit number 3 210
Figure 2.3.2:CIip-Window
In the Figure 2.3.2 the position of a point outside a window is repeated by
a set bit as follows:
bit position
0 = Point is left of the window
1 = Point is right of the window
2 = Point is below the window
3 = Point is above the window
27
ST 3D Graphics
Abacus Software
The code [0,1,0,1] means the following: the point is to the left and below
the window. With this information, it is possible to calculate the points of
intersection of the lines with the window edges by including them in the
equation. This leads to a quadratic equation system whose solution
requires several multiplications and divisions. For our purposes, we want
to limit the number of multiplications and to replace them when possible
with other mathematical operations. We do this for two reasons. The first
is for speed since multiplication requires about eight to ten times the
calculation time of addition. The second is the fact that the result of
multiplication, with the same number of significant positions of the
operands, has a larger relative error.
To get an optimal solution of the line-clipping problem requires a
programming language which permits bit manipulation. This was
developed by Cohen and Sutherland. Since the efficiency of the Cohen-
Sutherland clipping algorithm is so great, it is sometimes implemented in
the hardware of some graphic terminals.
The starting point of the algorithm is to divide the plane into the nine
areas previously illustrated. For every line which is to be "clipped”, you
must determine a center point and on the basis of its position relative to
the window.
The calculation of the center point of a line AB is simple. Just add the X
and Y coordinates of the end points and divide them by two.
Mx= (ax+bx) /2, My= (ay+by) /2. Division by two is performed by
microcomputers easily by a single right shift and this explains the speed
of the algorithm.
The 8 different positions of the end points relative to the window are
illustrated in Figure 2.3.2. Before calling the clip-routine, you must first
test to see if the two end points are visible. If any of the bits are set, then
some portion of the line is not visible. In Figure 2.3.2 both A and B are
above the upper window edge, and therefore the line AB is not visible and
no longer needs to be considered. You can calculate the position of the
points by "ANDing" their codes and then testing for a "not zero”
condition. For lines which have no common position parameter, for
example the line CD, positions are determined with two separate
procedures. First the right and then the left intersecting points with the
clip-window.
28
Abacus Software
ST 3D Graphics
First calculate the midpoint Ml of line CD. After determining the position
code of the point Ml, it is compared with the code of the right endpoint D.
If a single bit of these codes is the same, then the partial line MID does
not have to be considered further, and the right endpoint D is replaced
with the point Ml which was just determined. Now the midpoint of line
CM1 (M2) , is calculated and tested again with the right endpoint, this
time Ml. If both points are not on one side, M2 becomes the new left
endpoint and the right endpoint remains Ml. Next search the midpoint of
the line M2M1. This procedure is continued until a new calculated
midpoint is equal to one of the two end points used for calculation.
After completing the algorithm, the last left endpoint is the desired
intersecting point with the window. The intersecting point is stored and
the two starting points C and D are interchanged. With the same
procedure the intersection with the left window edge is determined. At
the start of the routine, if you find that an endpoint is already inside the
window, this endpoint must be stored. The line ST causes a problem. The
two end points S and T are not on the same window side and the line does
not intersect the window. A comparison of the first center point T1 shows
it matching both end points. The points T1 and T are both to the right of
the window and point S below the window. You can thus define a new
ending criteria--# a new midpoint lies outside of the window and matches
both end points of the line, then the line is not visible.
29
ST 3D Graphics
Abacus Software
2.4 Transformations in three dimensional space
A small warning before we start: Thinking in three dimensions requires a
period of adjustment for the non-mathematically oriented reader. It may
be necessary to read this chapter several times before the concepts can be
fully understood.
Starting with the two dimensional X-Y-coordinate system, there are two
ways to introduce a right angle coordinate system to describe three
dimensional space. They are the right-hand and the left-hand coordinate
system which differ only in the orientation of the negative Z axis.
A coordinate system is called a right-hand coordinate system when a
screw with a right-handed thread (a normal wood screw) moves in the
direction of the positive Z axis when it is turned from the positive X axis
in the direction of the positive Y axis. See Figure 2.4.2. The right-hand
coordinate system is used extensively in mathematics while some
computer graphic books select the left-hand coordinate system.
30
Abacus Software
ST 3D Graphics
Mathematical problems can be solved in either system and one system
can easily be turned into the other. We shall use both systems. The
transformations in three dimensional space will be explained on a right-
hand coordinate system, the perspective transformations on a left-hand
coordinate system.
z z
Right-hand Left-hand
Figure 2.4.2
All operations in a two dimensional space are special cases of
corresponding operations in three dimensional space. In the extended
coordinate system, the line vector of a point is expressed as:
P [x,y, z, 1]. To move the origin to the point V[vx,vy, vz, 1], use
the matrix T1:
T i =
1
0
0
•vx
0
1
0
■vy
0
0
1
-vz
0
0
0
1
So for every point: [x,y,z,l] * Ti = [x-vx,y-vy,z-vz,1]
31
ST 3D Graphics
Abacus Software
The scaling matrix is similar. A scaling factor for the Z axis (Sz) is
added:
Sx 0 0 0
S 1 = 0 Sy 0 0
0 0 Sz 0
0 0 0 1
For every point: [x, y, z, 1] * = [x*Sx, y*Sy, z*Sz, 1 ]
Rotation is limited to the three rotation axis: X,Y, and Z. We are already
familiar with rotation about the Z axis from the earlier 2D description.
The 3D description is derived by assuming that the positive Z axis
projects from the drawing surface. The coordinates of the axis about
which rotation takes place, does not change, in this case the Z coordinates
retain their values.
cos(zw) sin(zw) 0 0
R z = -sin(zw) cos (zw) 0 0
0 0 10
0 0 0 1
32
Abacus Software
ST 3D Graphics
Figure 2.4.3
We must also allow for setting a positive turning angle for the rotation
about the X and Y axes. A solution which can be applied to both the left-
hand and right-hand coordinate systems uses the following definitions:
Rotation axis positive angles are measured from
Z-axis
X- to Y-axis
Y-axis
Z- to X-axis
X-axis
Y- to Z-axis
From this follow the matrices for rotation around the X and Y axis R x and
Ry.
33
ST 3D Graphics
Abacus Software
10 0 0
R x = 0 cos(xw) sin(xw) 0
0 -sin(xw) cos(xw) 0
0 0 0 1
cos(yw) 0 -sin(yw) 0
R y = 0 10 0
sin(yw) 0 cos(yw) 0
0 0 0 1
For the coordinate system this means that if you look from a positive axis
in the direction of the coordinate origin, a positive angle describes a
counterclockwise rotation. In a left-hand coordinate system a positive
angle describes a rotation in the clockwise direction. This definition
applies to a fixed coordinate system in which the objects are rotated. The
other type of representation would be the fixed placement of the object
and the rotation of the coordinate system. The two types differ only in the
sign of the rotation angles. This means that if the object is rotated about
the angle alpha, or the coordinate system is rotated about angle alpha,
the result in both cases will be the same. In three dimensional space the
point of the rotation, as in the two dimensional plane, is the origin. If you
want to rotate an object around another point, it is first necessary to move
the origin to that point. The required steps are:
1. Change the origin to the point B[bx,by,bz, 1] using
translation matrix Ti.
2. Rotate around the Z axis with rotation matrix R x .
3. Retranslate the origin using translation matrix T 2
10 00 cos(a) -sin(a) 0 0
T]_= 0 1 0 0 Rl= -sin (a) cos (a) 0 0
0010 0 0 10
-bx -by -bz 1 0 0 01
10 0 0
T 2 = 0 1 0 0
0 0 10
bx by bz 1
34
Abacus Software
ST 3D Graphics
Figure 2.4.4
Let’s assume that you want to rotate an object about around all three
axes. It is then possible to combine the rotation matrices R x , Ry and R z
by multiplying with Rg. In contrast with the combination of rotations
about the same axis in this example the sequence of multiplications is
important, i.e. R x *Ry*Rz yields a result different from R z *Ry*R x . A
point with a positive Z value is rotated 90 degrees around both the Z and
X axes. If the rotation is first made about the Z axis, the coordinates do
not change, X- and Y-coordinates are equal to zero, and the subsequent
rotation about the X axis rotates the point to the Z=0 level; which is the
X-Y plane.
If the first rotation is about the X axis, the point is transferred to the Z=0
level and the subsequent rotation about the Z axis rotates the point into
the Y=0 level, which is the level between the X and Z axes. This example
shows why it is necessary to follow the sequence of rotations during
program generation.
35
ST 3D Graphics
Abacus Software
2.4.1 Rotation about any desired axis
Up to now we have only considered rotation about one of the coordinate
axes; with suitable combinations of various transformations we can turn
an object around any desired line in space. Two points Pl[xl,yl,zl]
and P2 [x2,y2, z2] are sufficient to describe a point in space. The
equation through these two points:
x = xl + t*(x2-xl)
y = yl + t*(y2-yl) with t elements from R
z = zl + t*(z2-zl)
36
Abacus Software
ST 3D Graphics
Since the problem for rotation about one coordinate axis has already been
solved, we want to transform a rotation axis in such a way that it will
coincide with the negative Z axis. The sequence of the transformation
looks like this:
Displacement of the coordinate origin to the point
PI [xl, yl, zl] on the line.
Rotation about the angle xw on the X axis, so that the
rotation axis lies in the X-Z plane.
Rotation of the angle y w about the Y-axis until the rotation
axis coincides with the negative Z axis.
It is now possible to rotate the desired angle zw about the Z axis since it
matches the rotation axis. If one looks from PI to P2 a positive angle
will rotate an object in a counterclockwise direction.
37
ST 3D Graphics
Abacus Software
To transform back to the original we need:
Rotation of the angle -yw around the Y axis
Rotation of the angle -xw around the X axis
Displacement of the coordinate origin at the starting point.
The only problem is the determination of the angles xw, yw, which can be
derived from the equation. As in Figure 2.4.7 we imagine that the
coordinate origin is already moved to point P1. Then the coordinates of
the point P2' [x2-xl,y2-yl, z2-zl] represent the direction vector
of the lines. This vector is now projected on the Y-Z plane, whereby the
term projection should be taken literally. In addition you should imagine
the vector G [gx, gy, gz] = G [x2-xl, y2-yl, z2-zl] illuminated
by light rays, parallel to the X axis and originating from the positive X
axis. The shadow created in the Y-Z plane is the vector L [0, gy, gz]
and the angle alpha between vector L and the positive axis Z is the
desired angle xw.
In a rotation about the X axis, a positive angle describes the rotation of a
point from the positive Y axis in the direction of the positive Z axis. The
angle alpha is positive and the rotation matrix is as follows:
R
x
10 0
0 cos(a) sin (a)
0 -sin(a) cos (a)
0 0 0
0
0
0
1
38
Abacus Software ST 3D Graphics
sin(a) = gy/1 and cos (a) = gz/1
For the rotation matrix R x this means:
1 0 0 0
r x — 0 gz/l gy/i 0
0 -gy/l gz/1 0
0 0 0 1
After this transformation, the vector G (P IP 2) lies in the plane located
between the positive Y and positive X axis. The angle gamma, which we
defined to be positive, is the desired angle (yw), which rotates the vector
G with one rotation about the Y axis on the negative Z axis. The rotation
matrix Ry:
39
ST 3D Graphics
Abacus Software
cos (g) 0
0 1
sin(g) 0
0 0
-sin(g) 0
0 0
cos (g) 0
0 1
It is possible to divide the angle gamma into the partial angles beta and
the right angle alpha’ (90 degrees), between the positive X and negative Z
axes. Through rotation about the X axis the X coordinate of the point P2
has not changed, whereas the Y c oordinate has beco me zero. The sum of
the vecto r G [gx, gy, gz ] g =V~ (gx 2 +gy 2 +gz ^) is therefo re identical
to g =V" (gx^+z l z ) . From this follows z ' =V” [g z -gx 2 ) and from
1 =V (gy 2 +gz 2 ) = V (g 2 -gx 2 ) results in z ' : z' = 1.
For the angle beta the following relationships result:
sin(b) = 1/g and cos (b) = gx/g
The rotation angle gamma is composed of beta plus 90 degrees,
ga - b + 90
40
Abacus Software
ST 3D Graphics
From tlffe addition theorems for sine and cosine we get:
sin <ga)=sin(b+90)=sin(b)*cos(90))+sin(90)*cos(b)
sin(ga) = sin (b+90) = cos(b)
cos(ga)=cos(b+90)=cos(b)*cos(90)-sin(90)*sin(b)
cos (ga) = cos (b+90) = -sin(b)
Since the rotation angle is measured positive, it is possible to include the
information just acquired directly into the rotation matrix.
-sin(b) 0
0 1
cos (b) 0
0 0
-cos(b) 0
0 0
-sin(b) 0
0 1
with the references to the angle functions:
-1/g 0 -gx/g 0
0 10 0
gx/g 0 -1/g 0
0 0 0 1
After these preparatory transformations, the rotation takes place about the
desired angle za about the rotation axis, which is the connecting line
between PI to P2. The matrix for this is:
cos(zw) sin(zw) 0 0
Rz =- sin(zw) cos(zw) 0 0
0 0 10
0 0 0 1
41
ST 3D Graphics
Abacus Software
The inverse transformation matrices:
The transformations for one point
-1/g 0 gx/g 0
Ry -1 =0 1 0 0
-gx/g 0 -1/g 0
0 0 0 1
10 0 0
R x 1 = 0 gz/1 -gy/1 0
0 gy/l gz/1 0
0 0 0 1
10 0 0
T -1 =0100
0 0 10
xl yl zl 1
P'[x',y', z',l]=[x,y, z, 1]*T*R x *R y *R z *R y -1 *R x -1 *T~ 1
In these cases the rotation matrices R x etc. are combined through
multiplication. The translations are performed separately.
42
Abacus Software
ST 3D Graphics
2.5 Projections from space to a two dimensional plane
A window can be made for observation in 3D space just as it can on a
2-dimensional plane. The position of the window and its orientation
relative to the world system is purely arbitrary. For definition of this
observation window you should imagine a second coordinate system, the
view system inside the world system. Its origin lies in the left comer of
the observation window.
As a position parameter which describes the position of the view system
relative to the world system, the two points ORP (Observation reference
point) and ODP (Observation direction point) are sufficient, both of
which are defined in the world coordinate system, as well as perhaps an
inclination angle between positive Y and positive V axis (za), which
describes a rotation of the U-V plane about the Z axis. The view system,
as illustrated in Figure 2.5.1 is a left system. The orientation of the
positive Z axis is opposite to the world coordinate system.
43
ST 3D Graphics
Abacus Software
For clarification: Every scene defined in the world coordinate system,
such as an airport for a flight simulator, can be viewed from any point
inside this scene. The only parameters required are the observation
reference point (ORP), which in comparison with a camera, would
represent the film, and the observation direction point (ODP), which
determines the direction in which the observer (the camera) is looking.
The additional angle used (za) between positive Y and positive V axes
describes a rotation of the camera about the longitudinal axis of the
objective. The focal point of the lens at which all light rays passing the
objective meet, would in this example be on the negative Z axis. Keeping
to the example of the camera, exposing a picture must transform the
entire scene into the view system (U-V-Z’).
This transformation, which appears complicated at first glance, has
already been solved: it is the rotation about an arbitrary axis. The points
PI and P2 of the axis of rotation are replaced by the points ORP and ODP
and the angle za describes the inclination of the V axis to the Y axis. All
operations relate to the observation reference point
(ORP [orx, ory, orz] ), the positive axis of the observation coordinate
system (view-system) points to the observation direction point
(ODP [odx, ody, odz]). Both points are described in world coordinates
and the rotation matrix rotates the vector G[odx-orx, ody-ory, odz-
orz] to the negative Z axis of the world coordinate system. After fitting
the V axis, the object, which was subjected to the same operations, is
available in the view coordinates. Not quite, though, since the two
coordinate systems still differ in the orientation of the Z axis. Therefore
after fitting the V axis, all Z values must be multiplied by the factor -1
which corrects the orientation of the Z axis. The last step is a
mathematical cosmetic which is required only because of the starting
model of the positive Z axis of the left-hand coordinate system. If one
views the result of the transformation as a right-hand system, the last step
can be omitted.
Let us combine the steps again, considering the steps necessary for
rotation around any desired axis.
44
ST 3D Graphics
Abacus Software
1. Shifting the origin to the observation reference point ORP
via the translation matrix Tj.
1
0
0
-orx
0 0 0
1 0 0
0 10
-ory -orz 1
2. Rotation around the X axis until the vector G[odx-
orx, ody-ory, odz-orz] = [gx / gy,gz] lies in the
Y-Z-plane.
10 0
R x = 0 gz/i gy/i
0 -gy/i gz/i
0 0 0
with 1 = V(gy2+gz 2 )
0
0
0
1
3. Rotation about the Y axis until the vector G[gx, 0, z']
meets with the Z axis:
-1/g 0 -gx/g 0
0 10 0
gx/g 0 -1/g 0
0 0 0 1
with g = V (gx 2 +gy 2 +gz 2 )
l = V7gy 2 +gz 2 )
z' = 1
4. Rotation of the Z axis around the za angle for adaptation
of the inclination of the V axis:
R
z
cos(zw)
-sin(zw)
0
0
sin(zw) 0 0
cos(zw) 0 0
0 10
0 0 1
46
Abacus Software
ST 3D Graphics
5. Multiplication of the Z coordinates with -1 to convert from
the right-hand to the left-hand coordinate system.
Mi
10 0 0
0 10 0
0 0-10
0 0 0 1
The object now lies in the left-hand coordinate system U-V-Z’ and can be
projected on the display, the plane suspended between the U and V axis
via a suitable perspective transformation.
47
ST 3D Graphics
Abacus Software
2.6 Perspective transformation
Since the representation of objects on the screen is limited to two
dimensions, we have to simulate the third dimension, the Z coordinate, in
the two-dimensional plane. The method we used, the central projection,
defines a point in space (the focal point of a lens) at which visual rays
emanating from the object meet. The size of the objects represented on
the display screen is directly proportional to their distance from this focal
point. Equal size objects which are farther away are shown smaller than
objects which are closer to the observer.
T
l i
*z
Figure 2.6.1: Perspective
The coordinate system from Figure 2.6.1 is, as already indicated, another
coordinate system and the plane suspended between the positive U and
the positive V axis at point z’=0 will represent the screen. The center of
the projection (focal point) is located on the negative Z axis at point
PROZ[prozx, prozy, prozz ' ] = [0, 0, prozz' ]. The position of the
point tc be viewed P[pu,pv,pz], appears to be located behind the
48
Abacus Software
ST 3D Graphics
observation plane. The line through these two points is described by the
following equation:
u = plu + (prozu-plu)*t
v = plv + (prozv-plv)*t
z' = plz' + (prozz' -plz') *t = 0 , the plane
lies at z'=0 =>
t “ -plz'/(prozz'-plz')
u = plu - (prou-plu)*plz'/(prozz'-plz')
v = plv - (prozv-plv)*plz'/(prozz'-plz')
z' =0
with prozu=prozv=0:
u = plu + plu*plz'/(prozz'-plz')
v = plv + plv*plz'/(prozz'-plz')
z = 0
Since prozz' is negative and plz' is positive, the denominator
(prozz' -plz') becomes negative, and with larger distances between
focal point PROZ and point PI, the point coordinates (in the projection
plane) plu' or plv' become smaller. We are now in the position to
project a three-dimensional representation of the object on the screen and
the distance of the projection-center object is comparable to the focal
length of a camera lens. A short length corresponds to a wide-angle lens
and a larger distance to a telephoto lens. The projections described are
valid for the special case of the projection plane at the point z' = 0. The
project plane can be moved freely on the z’ axis and can be behind the
object or also behind the eye.
49
ST 3D Graphics
Abacus Software
In this illustration the projection center is at the point PROZ, while the
object to be projected is the connecting line between the points PI P2.
d designates the location of the projection plane on the Z’-axis, which
can be moved arbitrarily in either direction. If the projection center and
projection plane (d=PROZ) match, all objects degenerate to a single
point, the center of the projection. The size of the projection can be
changed by moving the projection plane. For the line between projection
center PROZ and object point P1 the two point equation holds:
u = plu + (prozu-plu)*t
v = plv + (prozv-plv)*t
z' = plz' + (prozz'-plz')*t = d
50
Abacus Software
ST 3D Graphics
The Z’-coordinate of the projection plane is d, and from the equation for
the Z’-coordinate it follows:
t = (d-plz' ) / (prozz' -plz' ) inserted into the linear equation
results in the projection coordinates:
u' = plx + [(prozu-plu) * (d-plz')] / (prozz'-plz')
v' = p1v + [ (prozv-plv) * (d-plz')] / (prozz'-plz')
z' = d
Every point P[u,v,z',l] is transformed into the display coordinates P
' [u',v',d,l]. The coordinates u' and v' represent a point on the
screen.
The equation derived from Figure 2.6.1 comes from the special case
where the projection center lies on the Z axis prozu=prozv=0 and
when the projection plane is on the z'=0 plane, d=0. The following
illustrations show how the selection of the various observation parameters
(ORP, PROZ, d) influence the appearance of the projection. The
coordinate origin of the display is in the lower left comer of the screen.
51
ST 3D Graphics
Abacus Software
• projection center
Figure 2.6.3
52
Abacus Software
+ Z
ST 3D Graphics
resulting projection
Figure 2.6.5
54
Figure 2.6.6
ST 3D Graphics
Abacus Software
2.7 Hidden lines and hidden surfaces
Up to now we have been in the position to project wire models of objects
on the screen. The action sequence of most any computer animation is set
up with the help of 3-D wire models. Wire models can be handled in real¬
time and thus shorten the development of the animation sequence
considerably. Once the sequence is set, the computer calculates the
visible surface and color nuances and light reflections of the objects for
every intermediate point of the movement, according to the illumination.
Generally the scan line algorithm is used. Seen from the eye, the vision
rays are tracked through each pixel of the display (= projection plane) to
the individual objects. The visual ray is either reflected, absorbed, or
wholly or partially transmitted by various objects with differing surface
characteristics. Under certain conditions the visual ray splits, such as on a
glass surface, into a reflected and a second visual ray which passes
through the object, naturally both must be tracked. This explains the
computation time of about 10 minutes which even super-computers like
the Cray II require for a picture.
Since by conservative estimate the throughput of the Cray II is superior to
that of the Atari ST by a factor of about 10,000 to 15,000, it should be
clear that the ST is somewhat “under powered" for such calculations.
Therefore we will limit ourselves to the “surface algorithms" and will not
determine the visibility of every point, but just for each surface of the
object. These algorithms are fast. To be accurate, they are valid only tor
convex bodies, and in the version presented here the surfaces of the
bodies must also be convex.
56
Abacus Software
ST 3D Graphics
Figure 2.7.1: Convex and Concave Surfaces
With convex polygons the line connecting two points on the polygon lies
within the polygon, whereas in convex bodies the connecting line
between two points on the surface passes through the body or runs along
the surface. Formulated differently, convex polygons have at least one
inner angle which is larger than 180 degrees.
For these surface algorithms we must expand the object definition, which
up to now consisted of the point and line list, to include a surface list. The
surface list contains a description of each surface by the lines which
border the surface.
57
ST 3D Graphics
Abacus Software
The two surfaces I and II would be described in the surface list as
follows:
Surface Line from point to point
I Pl,P4 P4,P3 P3,P2 P2, Pi
II P5,P6 P6,P7 P7,P8 P8, PI
You probably noticed that the line direction is reversed in the description
of the surfaces. The line vectors of surface I describe the surface as seen
from the negative Z axis in a clockwise direction, while surface 11 is
described in a counterclockwise direction. This small difference contains
the solution to the hidden-line-problem. If you imagine the surfaces I and
II as outer surfaces of a block, then SI is the front surface and SI I the
rear surface of the block. The observation point is still on the negative Z
axis. SI I is not visible from the observation point since it is hidden by
the other surfaces.
58
Abacus Software
ST 3D Graphics
You can see that the description of the surface is always done in the
clockwise direction from outside the cube and looking toward the current
surface center. For the definition of the surface one wanders around the
object to be described and determines the direction of the connection
lines of the points belonging to the surface. As one can see in the next
illustration, the visibility of the surfaces can be determined through the
direction of the connection lines with a little vector algebra.
To do this, start from any point on the surface and form the vector to the
next point
P= [px,py,pz] = [p2x-plx,p2y-ply,p2z-plz] ,
and the vector to the next point
Q [qx, qy, qz] = [p3x-plx, p3y-ply, p3z-plz ],
as well as the projection vector from a point on the surface to observation
point A. An appropriate selection is the point
PI,S[sx,sy,sz] = [ax-plx,ay-ply,az-plz].
As explained in the appendix, the product of two vectors (a\b) (see
App. B) forms a vertical vector
R= [rx, ry, rz ] =[py*qz-pz*qy,pz*qx-px*qz,px*qy-
py*qx].
The direction of this vector results from the system in which the vector
product was performed. In the left coordinate system used here, the
vector d points in the same direction in which a screw with a left-handed
thread would move from P to Q when turned, that is, it points with
surface I in the direction of the positive Z axis and with surface II in the
direction of the negative Z axis.
Now we can say this about the visibility of surface I: if the vectors S and
R are pointing in the same direction, the surface is visible from the
observation point. If the vectors S and R point in different directions, the
surface is not visible. As mentioned earlier, this process is limited to
closed convex bodies, but the error is not very large with concave bodies.
59
ST 3D Graphics
Abacus Software
Figure 2.7.3-4: Hardcopy of bodies before and after
Hidden-Line-Algorithm
60
Abacus Software
ST 3D Graphics
Figure 2.7.5
61
ST 3D Graphics
Abacus Software
Figure 2.7.6
Figure 2.7.7
62
Abacus Software
ST 3D Graphics
The error with concave bodies is that surfaces which are visible from the
observation point are hidden by other surfaces but are not recognized.
Now only the "direction comparison criterium" between two vectors is
missing. This is accomplished by the scalar product of two vectors
(S *R) which is defined as follows:
c = |SI * IRI*cos(Phi) = sx*rx+sy*ry+sz*rz
cos(alpha) > 0
Figure 2.7.8
c is a real number and phi is the angle enclosed by S and R. From
Figure 2.7.8 we can see that the vectors a and b point in the same
direction when cos (phi) is positive. The recognition of hidden
surfaces can be summarized as follows.
1. Creation of a surface list in which the points are listed in a
clockwise direction.
2. Finding the vectors P and Q from three successive points
for each surface.
63
ST 3D Graphics
Abacus Software
3. Determination of the vector S [sx, sy, sz ] from a point
on the surface to the observation point.
4. Determination of the vector perpendicular to P and Q
R [rx, ry, rz ] through the vector product (P\Q).
5. Comparison of the direction of the vectors S and R by
checking the sign of the scalar product (S*R) through
multiplication of the single components from S and R
(Scalar product = sx*rx+sy*ry+sz*rz)
6. Marking of surfaces which have positive scalar products as
visible surfaces. (Applies to left coordinate systems. In
right coordinate systems the surfaces with negative scalar
products are visible surfaces.)
7. Drawing the visible surfaces.
64
Abacus Software
ST 3D Graphics
2.8 Rembrandt and hidden surfaces
You probably want to know what computer graphics and a painter who
died in 1669 have in common. An oil painting is created from back to the
front, that is to say, the painter first draws the background and then
objects are placed further to the front simply by covering the background
with oil paint. This method, carried over to the computer, is another
solution of the hidden surface problem. A middle Z coordinate is
calculated for each surface and, as an example, all Z coordinates of the
comer points can be added and divided by the number of comer points
which are stored for the surface. Then the surfaces are sorted according to
size and drawn from the largest to the smallest Z coordinates.
To insure that the surfaces which are painted over have really been
covered, we can’t just to draw the outer lines of the surface. It is
necessary to fill the surfaces with color. The surface construction from
the back to the front is shown in the following illustrations.
Figures 2.8.1-5: Hardcopy of the surface construction
Figure 2.8.1
65
ST 3D Graphics
Abacus Software
Figure 2.8.2
Figure 2.8.3
66
Abacus Software
ST 3D Graphics
ST 3D Graphics
Abacus Software
Figure 2.8.6
Figure 2.8.7
68
Abacus Software
ST 3D Graphics
Figure 2.8.8
Of course, the two methods for the removal of hidden surfaces can be
combined. First the visible surfaces can be determined through scalar
products. Followed by sorting the surfaces according to descending Z
coordinates, and then drawing them.
69
ST 3D Graphics
Abacus Software
2.8.1 Light and Shadow
In general, there are two types of illumination, direct and indirect. With
indirect illumination the intensity of the light is equal on all places in
space. The indirect light is created through diffuse reflection from other
objects, such as walls and ceilings. The appearance of an object in space
under this illumination is dependent only on the reflection coefficient of
the object. This reflection coefficient is the relationship of reflected light
rays to the total striking the surface. Its value runs from zero for a black
body (all light rays which strike are absorbed) and one for a white body
(all light rays which strike are reflected). A body whose reflection
coefficients are between zero and one is designated as a gray body. A
reflection coefficient R can be given for every surface which determines
the intensity of the surface.
Intensity = R * IL with IL = Intensity of available indirect
light.
A more realistic representation results from the definition of one or more
point light sources in the space. These point light sources, for example
lamp, candle, or sunshine, have a certain position in the space and shine
in the direction of the object. In this case, the orientation of the
illuminated surface to the light source is of great importance. More light
rays fall on a surface which is perpendicular to the light source than an
equally large surface which is not perpendicular to the light source.
The orientation of the surface to the light source can be determined by
comparing the normal vector of the surface (the vector perpendicular to
it) with the vector to surface from the light source. If L and N are two
vectors of length 1, the relation for the angle between L and N is:
L*N = lx*nx+ly*ny+lz*nz = cos(w)
For the gray value of the surface the result is then:
Intensity = R*IL + R* (L*N) *DL
with the reflection coefficient R and the intensity of the direct light source
DL, which is between zero and one.
70
Abacus Software
ST 3D Graphics
Figure 2.8.9: Surfaces with Light Rays
71
r
Machine Language Fundamentals
for Graphic Programming
Abacus Software
ST 3D Graphics
3. Machine Language Fundamentals for Graphic Programming
All programs described in this book may be run on various ST
computer/monitor combinations. To simplify the compatibility, all
drawing functions for the 3-D graphics project were done with operating
systems functions (line-A). To introduce you to machine language
programming on the ST, we first have an explanation of some of the basic
principles (sine) and then a small program for drawing random lines. This
program illustrates the program interface to the operating system and a
simple line-drawing algorithm which writes directly to the screen. The
line-drawing algorithm is not necessary for the 3-D project coming later
and is intended only as an example. The use of the algorithm is limited to
monochrome monitors. Owners of color monitors can replace the call
drawl with ddrawl (indicated in the listing) if they want to run the
program mainl. s.
75
ST 3D Graphics
Abacus Software
3.1 Speed Advantages from tables
Before starting a project in machine language, you should think about the
number format to be used. For all the following applications we can
perform all calculations with 16-bit integers. Another problem is the sine
function, whose function values can range from -1 and +1. The function
values can be approximated on computers using the Taylor series, which
approximates the exact function value through repeated summation of the
terms of a sequence. In practice, the summation can be terminated after 3
or 4 terms. As an example, we have here the Taylor series for the sine
function.
sin(x) = x - xV3! + x 5 /5! - x 7 /7! + ...
The angle x is given in radians, and 3! means 3 factorial = 1*2*3 = 6.
This method is not suitable for quick calculation of sine and cosine values
because several multiplications must be performed for each function
value. A rather unelegant but simple and common solution is to store all
the necessary function values in a table in memory, which can then be
accessed very quickly.
The accuracy can be set as desired since the function values are
calculated before the actual program application and the time factor does
not play a role. In our example, all sine values between 0 and 360 degrees
are entered in steps of one degree. This is quite adequate for almost all
applications which require trigonometric functions. Should an
intermediate value be required, it can be interpolated from the table.
Since the cosine function is the same as the sine function shifted by 90
degrees, the cosine functions can also be taken from the sine table.
The function values of the angle functions are real numbers which are
floating point numbers with several places after the decimal point. Since
all our calculations involve only integers, it is necessary to transform the
values of the sine function. This is done by multiplying by a sufficiently
large number-in our example with 214 = 16384.
76
Abacus Software
ST 3D Graphics
The length of the line c and the angle alpha are already known, and we
want to find the length of b. According to the definition of the angle
function, the length of the distance =c* sin (a) = 20*sin(45). The
sine of 45 degrees is 0.707106781 with nine-place precision. In our table
we have the value 0.707106781 * 16384 = 11585 for 45 degrees. After
multiplying by 20 we got the number 231700 as a result. We don’t have
to worry that this number will exceed the value range of 16-bit integer
arithmetic because the processor always produces a 32-bit product as the
result of a 16-bit multiplication. This 32-bit result, the number 231700,
can now be adapted to the original value range by dividing by 16384, and
we get 14 as the result.
You may ask yourself why 16384 was used for the multiplication: first of
all the number is large enough to extend the range of the sine function.
Numbers between -1 and 1 become numbers between -16384 and
+ 16384. Second, the multiplication can be performed with two very fast
commands of the processor. Multiplications by a multiple of two can be
replaced in all microprocessors with shift commands which don’t take
much more time than an addition.
77
ST 3D Graphics
Abacus Software
At this point I would like to briefly discuss the possibilities of the table
representation in the computer. The sine table is the simplest form of a
table, a linear list. The individual table values are stored sequentially in
memory. Our sine table for the first values looks like this:
sintab: .dc.w 0,286,572,857,1143,1428,1713,1997,2280
.dc.w 2563,2845,3126,3406,3686,3964,4240,4516
.dc.w 4790,5063,5334,5604,5872,6138,6402,6664
Since the gradations of the angles are in 1 degree steps, the first table
value gives the sine of 0 degrees, the second the sine of one degree, the
third the sine of two degrees, etc. The 91st table value is the sine of 90.
table value and the sine of 360 degrees is represented by the 361st value.
Zero is chosen as the start to match the table numbers to the
corresponding angle. This means that table value zero represents the sine
of zero degrees. Value number 90 corresponds to 90 degrees and 180 to
180 degrees. The 68000 computer makes access to this table very easy
through its excellent addressing capabilities. The initial address of the
table is loaded into the address register. This is the address where the zero
element is stored. With the number of the desired table value in a data
register it is possible to access the location using the addressing mode
"address register indirect with index." In this table format it is absolutely
necessary to pay attention to the data length of individual entries. The
address of the zero value is equal to the beginning address of the table
plus zero, but the address of the first value is the beginning address of the
table plus two, since each value occupies two bytes. This means that the
index number in the data register must be multiplied by the number of
bytes for one entry. In this case it is two bytes. This multiplication by two
is very fast with one left shift of the bits in the index number.
78
Abacus Software
ST 3D Graphics
3.2 Assembler routines for screen manipulation
The screen of the Atari ST is organized using what is called bit-mapped
graphics. This means that bits which are set in the screen storage
correspond directly to dots on the monitor and therefore there is no
difference between text and graphics. Since the screen memory is part of
the main memory of the CPU, it can be manipulated quickly, i.e. without
waiting cycles. For monochrome display the resolution is 640*400 points,
which are represented by 400 times 640 bits in RAM.
Address: $78000 _ $78001 _ $78002 _ ■■■$7804F X 0>*= X >- 639 ^
$78000
76543210 76543210
$78050
Bil number
$780A0
$780F0
$780F1
$7FCB0
1
Y 0 >- Y >- 399
r
Figure 3.2.1
The only routines required for screen manipulation are those for
displaying a point and for drawing and erasing lines. A line of the video
picture is formed from 80 bytes and the total picture is made up of 400
lines. The address of a picture point can be calculated as follows:
address = screen start + Y*80 + INT(X/8)
79
ST 3D Graphics
Abacus Software
The bit number of the byte can be obtained with the following formula:
number = 7 - (X MOD 8)
The function I NT truncates the positions after the decimal point of a real
number, while the function MOD returns the remainder of the operand by
the second. For example, 9 MOD 2 returns 1 as the result Screen start is
the starting address of the screen memory, which is $78000 on the 520 ST
and 8F8000 on the 1040 ST
It may appear to be somewhat unusual to have the coordinate origin in the
upper left comer, but it is easy to change to the lower left comer and this
is accomplished by negating the Y values and adding 399. The X
coordinates remain unchanged of course , since the zero point is already
in the left comer of the display. The Y coordinate 370 in a normal left
system becomes (-370+399) = 29 in the screen system. This conversion
need be made only immediately before points are drawn. Some
calculations are required to draw a single point. The speed advantage of
tables for the calculation of the address of a point should also be
considered here. This table holds the RAM address for every possible Y
coordinate. This saves a multiplication for every calculation of the screen
address. Since the plot-point routine is used very often for drawing lines,
the speed advantage gained by using this table is correspondingly great.
3.2.1 Drawing lines
Since the size of a point on the screen is dependent on the resolution of
the computer, it is not possible to represent a line in the mathematical
sense. A line which connects two points PI and P3, actually takes a more
or less jagged path.
80
Abacus Software
ST 3D Graphics
T
Xi
Figure 3.2.2
Starting from point PI, you have the problem of deciding which points
must be set, in order to reach point P3. Note that it is possible to set the
points only at the intersections of the raster lines. The line is formed when
either the X coordinate is retained and a point drawn with an incremented
Y coordinate or you can increment the X coordinate while the Y
coordinate retains its value.
In mathematics, a line which connects two points is described through its
slope m. m is a measure of the "steepness" of the line and the larger m
becomes, the steeper the line becomes. With a positive m, the line rises
from left to right, while with a negative m it slopes down from left to
right For a line parallel to the Y axis, the slope is infinite. The expression
for the slope:
m = dy / dx
81
ST 3D Graphics
Abacus Software
Figure 3.2.3
See Figure 3.2.4 for an explanation of the algorithm for drawing of lines.
82
Abacus Software
ST 3D Graphics
Figure 3.2.4
Let us assume that in drawing the line from PI to P3 that we have
already reached the point P2 already and now have to decide the direction
in which to draw. In our example, the point P2 is ’’over" the ideal line
from PI to P3. Expressed mathematically, the slope of the connecting
line from Point PI to P2 ml=(p2y-ply)/(p2x-plx) = wy/wxis
greater than the rise of the line which connects the points PI and P3
m2= (p3y-ply) / (p3x-plx) =dy/dx. As the illustration shows, the
next step in drawing must be made in the X direction.
With the comparison of the two slopes, we have found a decision
criterion for the direction of drawing: If the slope of the connecting line
between the starting point of the drawing PI and an intermediate point
P 2 is greater than the slope of the line between the beginning and end
points (PI, P3), a drawing step should be made in the X direction . If
the slope is smaller, the next point should be drawn in the Y direction.
For the purpose of programming this criterion we shall define a decision
variable D, which is assigned the difference between the desired and the
actual slope.
83
ST 3D Graphics
Abacus Software
D = (dy/dx)-(wy/wx)
If D is larger than zero ==> Step in Y direction
If D is smaller than zero ==> Step in X direction
After a small conversion we get:
D*dx*wx = (wx*dy)-(wy*dx)
Multiplications slow down calculations, so we should try to eliminate
them from the calculation. The exact value of D is of no interest. It is only
important to know how D changes with a step in the X or Y direction so
that an eventual change in the sign of D can be recognized. For this
reason it is also possible to replace the expression D*dx*dy with D
again.
D = (wx*dy) - (wy*dx)
During a step in the X direction, wx is increased by one while we retain
the old value of wx. For our D which we call new D or ND to distinguish it
from D, the following results:
ND = (wx+l)*dy - wy*dx
ND = wx*dy + dy - wy*dx
The last expression is equal to old D + dy, where old D corresponds to
the value of D before the step in the X direction. Analogous to this for a
step in the Y direction:
ND = wx*dy - (wy+l)*dx
ND = wx*dy - wy*dx - dx
As you can see, D is reduced by dx with a step in the Y direction. For ND
can be written:
Step in Y direction ND = D - dx
Step in X direction ND = D + dy
84
Abacus Software
ST 3D Graphics
The multiplications have been replaced according to our desires by
additions. To formulate the algorithm, we must still decide in what
direction we will draw if D is zero. This can be decided at random and in
our example ND=0 results in a step in the Y direction. Another special
case which has not been mentioned is when dy is zero. In this case, steps
can be made only in the X direction since the resulting line must be a
parallel to the X axis. This case can only be determined with a test at the
beginning of the routine.
Furthermore, we have only considered lines with a positive slope, that is,
those where py3 is smaller than pyl. To retain the decision method in
this form, it is necessary to make negative dx and dy values positive
through multiplication with -1, and to decrease the X and Y coordinates
by one instead of increasing them for every step in the X or Y direction.
The algorithm for drawing a line between the points PI [xl, yl] and
P 3[x3,y3] appears like this in a structogram:
85
ST 3D Graphics
Abacus Software
Figure 3.2.5: Structogram Draw line
86
Abacus Software
ST 3D Graphics
3.3 Operating system functions
Since we will use only operating system functions for the 3-D graphics
programming, some should be explained before they are used. One of
these functions is the routine for switching the beginning address for the
video controller. All computers which which can display animated
graphics quickly and flicker free have the ability to work with two logical
screen pages internally.
Fast drawing and erasing of objects on the screen and the rapid accesses
to the screen RAM by the computer and the video controller, causes the
monitor picture to be unstable and to flicker. If the hardware has the
ability to tell the video controller where in RAM the screen memory
starts, the strategy for the creation of flicker free graphic is very simple.
We define two logical screen pages. We will use the Atatri ST as a
concrete example: in the Atari ST with 512K RAM the standard screen
page is stored between $78000 to $7FFFF and it is possible to define a
second screen page from $70000 to $77FFF. In the initial state, both
screen pages are erased and the video controller shows the page starting
at $78000. Now the first picture can be drawn in the RAM starting at
address $70000. After drawing the picture, the video controller is
informed at a suitable time of the new beginning address for the screen
RAM ($70000). A suitable time for switching is the time period in which
the electronic beam which draws the video picture returns, without being
seen, from the lower right comer of the screen to the upper left corner.
This moment is even recognized by the operating system and the
switching of the screen pages can be solved without any major
programming effort. If the page starting at $70000 is being displayed by
the video controller, the CPU can draw another picture, such as the object
in another position, in the page starting at $78000 without disturbing the
picture construction. After the new picture is completed, pages are
switched again and you can erase the old picture in the storage area which
is not being displayed. In general, the page which is being displayed is
considered to be the physical page in which the drawing is taking place is
the logical page. Only when both are identical do you see the progress of
the drawing on the screen.
87
ST 3D Graphics
Abacus Software
3.3.1 Starting a Program
To start a machine language program on the Atari ST you have to know
what happens when a program icon is clicked with the mouse. The
operating system loads the appropriate program and passes control to the
program once it is loaded. After loading a program, the operating system
declares the entire memory as occupied so that it is not possible to move
data or program sections. To avoid this disadvantage, the called program
must determine its actual memory requirements, declare this area as
occupied, and leave the rest of the memory free. The Atari operating
system simplifies this task by passing a pointer on the stack to the called
program indicating the memory area occupied by the program and data.
The called program can calculate the memory actually required and
declare the unused area as vacant to the operating system. Note:
sufficient space must be reserved for the processor stack. From the
Digital Research documentation, it is not clear how much stack space is
required for the GEM functions, but the 4K bytes reserved for this
purpose in the example should be sufficient for all purposes. To make it
possible to use all GEM functions, it is recommended that the program
call the functions Application-Init and then Open-Virtual-
Workstation when it starts. After these two calls, GEM-DOS, the
BIOS, Extended-BIOS and the AES and VDI functions are available to
the program. An overview of these functions are available in the two
Abacus Software books Atari ST Internals and the large Atari ST GEM
Programmer’s Reference.
All programs in this book were written using the assembler from Digital
Research. For users of other home computers the assembler is probably
new, and so I want to discuss it briefly. The assembler is completely disk
oriented, i.e. all input and output comes from and goes to the diskette.
First you create the source text of the program with an editor, store it on a
diskette and call the assembler with name of the source text The
assembler processes the source text by creating several auxiliary files on
the diskette. Finally it writes the desired object file on the diskette.
The object file which was created, recognizable by the extension . o, is
not executable since it was assembled at the absolute address zero. To
generate an executable program the absolute addresses must be replaced
with relative addresses to make it possible to load the program into any
memory area. For this purpose, you call the program RELMOD.PRG
88
Abacus Software
ST 3D Graphics
which then creates the desired run-time program file. In this you can
write manner machine language programs whose length is limited only by
the storage capacity of the computer and the floppy disk. It is impossible
to combine two programs which are already object files with this method,
however.
For this reason, one usually adds an intermediate step, as is also done
with higher level languages, called linking. The linker permits several
separately-assembled object files to be combined into one single file.
Large assembly language programs quickly become difficult to
understand and it is recommended that they be divided into at least two
modules. The first module initializes the program and contains all of the
error-free and tested subroutines, while the second module contains the
latest main program. This can reduce the assembly time considerably
since the large basic module must be assembled only once and afterwards
only linked to the main program. The use of the linker also permits the
use of assembler directives which would otherwise not be possible. The
assembler in conjunction with the linker can manage three separate
program areas: text, data, bss. The text area contains the actual program,
i.e. the program text, and the data area contains the initialized data. These
are variables to which values were assigned already before the start of the
program. In the bss area there is storage space reserved for the data which
has not been initialized.
Each of the programs; assembler, linker and relocator require parameters,
which are passed during the start. To assemble the basic module, first
select AS68.PRG and then INSTALL APPLICATION from the
OPTIONS menu as TOS-takes parameters. Then enter the following line
into the dialog box which appears:
-p -I -u basicl.s > basicl.lst
where basic 1. s is the name of the text file to be assembled. The -p
and > basicl.lst statements create a listing to the disk of the
assembly process which can later be printed for examination. The
assembler creates a file with the name basicl.o. This object file
contains the tested subroutines and will be linked to the current main
program.
89
ST 3D Graphics
Abacus Software
To assemble and link the main program, it is best to create a batch file,
which contains the individual command sequences. The batch file could
look like this:
as68 -1 -u %2. s
wait.prg
link68 [u] %2.68k=%l.o,%2.o
relmod %2.68k %2.prg
rm %2.68k
rm % 2.o
wait.prg
This batch file might be stored under the name aslink.bat on the
diskette. The batch file is made very flexible through the use of two place
holders, %1 and %2. To assemble the main program with the name
mainl. s and the subsequent linking with the basic module basicl. o
You call the program batch.ttp and pass the command sequence in
the dialog box:
aslink basicl mainl
After the assembly process the desired program file mainl.prg is
finally on the diskette. This creation of modules makes working with the
disk drive more bearable and the coffee breaks during assembly shorter.
As a practical test of all this, we have here the first version of the
basicl . s program and the first demo program. The basic program
contains only the initialization of the program and the basic routines for
screen manipulation such as screen erasing, and drawing of points and
lines. Assembly is done with:
as68 -1 -u basicl.s
The first main program demonstrates the speed of the computer by
drawing random lines and demonstrates how to call the operating system.
The steps for the creation of the ready-to-run program file mainl .prg,
without using a batch file are as follows:
1. Assemble MAIN1.S with the AS68.PRG.
90
Abacus Software
ST 3D Graphics
2. Link the two object files with the
Linker.
Iink68 [u] mainl.68k = basicl.o,mainl.o
3. Create a relocatable program with
relmod mainl.68k mainl.prg
The file mainl. prg can be started by clicking with the mouse after the
file Relmod, the two files mainl. o and mainl. 68k, which are no
longer needed, are erased with the program RM.
The listing should be self-explanatory with all of its comments. It should
offer an easy introduction to graphics programming in machine language.
More detailed explanations of the routines used can be found with the
explanation of the link files grlinkl.s in section 4.1. Starting with
Chapter 4 we will really start to program.
91
ST 3D Graphics
Abacus Software
***********************************************************************
* Link file basicl.s, is linked with the main program whose entry *
* routine must have the name main. *
* U.B. 11.85 *
***********************************************************************
.globl wait,wait1,drawl,ddrawl,inlinea
.globl grafhand
•globl grhandle
.globl global,contrl,intin,intout,ptsin,ptsout,addrin,addrout
.globl apinit,openwork,clwork,aes,vdi
.globl inkey
.globl mouse_on,mouse_off,printf
.text
*******************
* Entry to the program, initialization of all operating system *
* functions and creation of the Y-tables (For computers with color *
* monitors, replace "jsr startl" with "jsr start2". *
* Furthermore when using a color monitor/ replace all *
* "jsr drawl" calls in the main program with "jsr ddrawl".
**********************
art:
★
initialize the program
movei1
a7, a5
★
Base page address is on the stack
move.1
A (a5),a5
*
base page address = program start - $100
move.1
$c(a5),dO
*
Program length
add. 1
$14(a5),dO
★
Length of initialized data area
add. 1
$lc(a5),dO
★
Length of data area not initialized
add. 1
#$1100,dO
*
4 K-Byte user stack=sufficient space
move.1
a5,dl
★
Starting address of the program
add. 1
dO, dl
*
Plus number of reserved bytes = space required
and. 1
#-2,dl
*
even address for stack
move.1
dl, a7
*
User stackpointer to last 4K- byte
move.1
dO, -(sp)
*
Length of reserved area
move.1
a5, -(sp)
*
Beginning address of reserved area
move.w
dO,-(sp)
★
Dummy-Word
move.w
#$4a,-(sp)
★
GEM DOS function SETBLOCK
92
Abacus Software
ST 3D Graphics
trap
#1
add. 1
#12,sp
★
old stack address restored again
jsr
start1
*
Create Y-table
jsr
main
*
Jump to main program. ( User-created
move.1
#0,- (a7)
*
Terminate program running
trap
#1
★
Back to Gem-Desktop
********************************************************************
* Call a AES-Routine, where the parameters are passed to *
* to the various arrays (contrl,etc.) *
********************************************************************
aes: move.1 #aespb,dl * call the AES routines
move.w #$c8,d0
trap #2
rts
************************************************************************
* Call a VDI-Routine *
ft********************************************************************
vdi: move.l #vdipb,dl * call the VDI routines
move.w #$73,dO
trap #2
rts
**********************************************************************
* Announce the program *
**********************************************************************
clr. 1
dO
move.1
dO,aplresv
move.1
dO,ap2resv
move.1
dO,ap3resv
move.1
dO,ap4resv
move.w
#10,opcode
move.w
#0,sintin
move.w
#1,sintout
move. w
#0,saddrout
move.w
#0,saddrin
jsr
aes
rts
* Announce the program as
* Application
93
ST 3D Graphics
Abacus Software
***********************************************************************
* Check on screen handler and store for other functions *
***********************************************************************
grafhand: move.w
#77,contrl
* Get the screen handler
move.w
#0, contrl+2
* and store it in the global
move.w
#5,contrl+4
* Variable grhandle
move.w
#0,contrl+6
move.w
#0,contrl+8
jsr
aes
move.w
intout,grhandle
rts
***********************************************************************
* Open a Virtual Screen Work Station where all GEM drawing functions *
* will occur. *
***********************************************************************
openwork: move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move. w
move.w
move. w
move.w
move.w
move.w
move.w
jsr
rts
#100,opcode
#1, d0
#0,contrl+2
#11,contrl+6
grhandle,contrl+12
dO,intin
dO,intin+2
dO,intin+4
dO,intin+6
dO,intin+8
dO,intin+10
dO,intin+12
dO,intin+14
dO,intin+16
dO,intin+18
#2,intin+20
vdi
* open a workstation
* screen handler
94
Abacus Software
ST 3D Graphics
*'*******★★*******★***★**★★★**’***★***★*★★**★**★***★**★★**★★★★★*******★★*
* Clear the workstation *
***********************************************************************
clwork:
move.w
#3,contrl
* Clear
workstation
move.w
#0,contrl+2
* clear
the screen
move.w
#1,contrl+6
move.w
grhandle,contrl+12
jsr
vdi
rt s
* Turn on the mouse and its control. *
move. w
#122,contrl
* turn on the mouse
move.w
#0,contrl+2
* its control
move.w
#1,contrl+6
move.w
grhandle,contrl+12
move.w
#0,intin
jsr
rts
vdi
***********************************************************************
* Turn off the mouse and control. *
***********************************************************************
mouse off:
move.w
#123,contrl
* turn off the mouse
move.w
#0,contrl+2
* its control
move.w
#0,contrl+6
move.w
grhandle,contrl+12
jsr
vdi
rts
95
ST 3D Graphics
Abacus Software
*********************************
* Write a string on the screen
*********************************
printf:
move. 1
aO,- (a7)
move. w
#9,-(a7)
trap
#1
addq. 1
rts
#6,a7
wait 1
dbra
rts
dO,waitl
wait:
move.w
#1, -(a7)
trap
#1
addq.1
rts
#2,a7
*************************************
*
*************************************
* write the string, whose
* beginning address is in
* register AO, on the screen.
* String must terminate with
* zero.
* Time loop, counts the dO-Register
* down to -1
* wait for a key stroke
* GEM-DOS-Call
* Sense keyboard status (does not wait for keypress) and return key *
* code and also the scan code.
inkey:
move.w
#2,-(a7)
★
Sense keyboard, does not wait for key
move.w
#1,-(a7)
*
activation and return an ASCII-code
trap
#13
★
of an activated key in the lower half
addq.1
#4,a7
★
of the long word of DO, and the scan code
tst. w
dO
*
in the upper half of the long word of
bpl
endkey
★
DO.
move.w
#7,-(a7)
trap
#1
addq.1
#2,a7
endkey:
rts
96
Abacus Software
ST 3D Graphics
e********************************************************************
* Draw-line-routine, draws directly into the screen storage and is *
* used only for the high resolution mode {640*400 Points ). For color *
* monitor use ddrawl
************************************
drawl:
move. 1
d7,-(a7)
*
move.1
#ytab,aO
*
clr. 1
d4
move. w
#1, a4
*
move. w
a4, a5
*
move. w
a2,d6
sub. w
d2,d6
*
bge
dxispos
neg. w
d6
*
move. w
#-l,a4
*
dxispos:
move .w
a3,d7
sub.w
d3,d7
*
bgt
plotit
*
beq
dyis 0
*
neg. w
d7
*
move .w
#-l,a5
*
bra
plotit
dyis_0:
not. w
d4
*
plotit:
tst .W
d2
*
bmi
draw_it
*
tst. w
d3
bmi
draw_it
cmp. w
#639,d2
bhi
draw_it
cmp. w
#399,d3
bhi
draw_it
move.w
d3,d0
*
lsl. w
#2, dO
*
move.1
0(aO,dO.w),al
*
move.w
d2,dl
*
lsr .w
#3, dl
*
move.w
d2,d0
*
not. w
dO
*
*
**********************************
Save register
Address of the Y-table
X step = +1
Y step = +1
DX in d6 = X2 - XI
If DX is negative, then
make positive through negation
DY in d7
If DY is larger than zero draw then
first point
DY is negative, make positive
Y-Step is then -1
If DY = 0 then parallel to X-Axis
Test if drawing area was
exceeded
Y-value times two for access to
Plot table
Screen address
X-value
INT (X/8)
X-value
-X
97
ST 3D Graphics
Abacus Software
**********************************
* Here the point is drawn *
**********************************
bset
dO, 0(al,dl.w)
*
7-(X MOD 8) with the bset-command
draw it:
cmp. w
d2,a2
*
End X reached?
bne
notend
*
no
cmp. w
d3, a3
*
End Y reached?
beq
endit
*
no
notend:
tst .w
d4
★
D > 0 => Y step
bge
ystep
xstep:
add. w
a4,d2
★
else X step X=X+-1
add. w
d7,d4
★
ND = D + DY
bra
plotit
ystep:
add. w
a5, d3
*
Y=Y +- 1
sub. w
d6, d4
*
ND = D - DX
bra
plotit
drawend:
endit:
movem.
1 (a7)+,d7
*
restore register
rts
★
Return to calling program
**********************************************************************
* This Draw-line-routine is universal for all monitor types and *
* can be used with all resolutions. *
**********************************************************************
move.1
d7,-(a7)
move.1
tlineavar,aO
move.w
d2, 38 (aO)
*
XI
move.w
d3,40(aO)
*
Yl
move.w
a2,42 (aO)
*
X2
move.w
a3,44(aO)
*
Y2
-dc. w
$a003
*
draw line
move.1
(a7)+,d7
rts
98
Abacus Software
ST 3D Graphics
**********************************************************************
* Initialize the Line-A variables and store the address of the *
* Variable block in lineavar. *
**********************************************************************
inlinea:
.dc. w
$a000
★
initialize the Line
move.1
aO,lineavar
move.w
#0,32 (aO)
move.w
#$ffff,34 (aO)
*
Sample of the line
move.w
#0,36(aO)
*
Writing mode
move.w
#1,24(aO)
*
drawing color
rts
* Creation of the Y table for the highest graphic mode (640*400) *
startl:
move. w
#2,-(a7)
*
checks the screen address of the
trap
#14
*
System, recognizes which computer
addq. 1
move.1
#2,a7
d0,physbase
*
Display start minus 32 K-Byte
move. 1
#399,dl
*
Number of lines minus one
move. 1
#ytab, aO
*
Physical address
stloopl:
move.1
dO,(aO)+
*
New address equals old address
add. 1
#80,dO
*
plus 80
dbra
rts
dl,stloopl
* Line-A initialization *
start2: jsr inlinea * Initialize line A
rts
99
ST 3D Graphics
Abacus Software
********************************************************************
* Variables of the basic program *
********************************************************************
lineavar:
.even
.bss
.ds. 1
1 * Storage for address of Line-A variable
physbase:
.ds. 1
1 * Storage for screen address.
ytab:
.ds. 1
400 * Storage for the Y table
contrl:
* Arrays for AES and VDI functions
opcode:
.ds .w
1
sintin:
.ds.w
1
sintout:
.ds. w
1
saddrin:
.ds.w
1
saddrout:
.ds.w
1
.ds.w
6
global:
apversion:
.ds.w
1
apcount:
.ds.w
1
apid:
-ds.w
1
apprivate:
.ds. 1
1
apptree:
.ds. 1
1
aplresv:
.ds.l
1
ap2resv:
.ds. 1
1
ap3resv:
.ds.l
1
ap4resv:
.ds.l
1
intin:
.ds.w
128
ptsin:
.ds.w
256
intout:
• ds.w
128
ptsout:
.ds.w
128
addrin:
.ds.w
128
addrout:
.ds.w
128
grhandle:
.ds.w
1
vdipb:
.data
.dc. 1
contrl,intin,ptsin,intout,ptsout
aespb:
.dc. 1
contrl,global,intin,intout,addrin,addrout
.end
100
0
Abacus Software
ST 3D Graphics
***********************************************************************
* Main program for link file basicl.o , runs only in connection with *
* this link file . U.B. 11.85
* Draws random line in coordinate area 0-255. The value area
* is valid for both axis
***********************************************************************
.globl main
.text
* Entry point from the linkfile
*
main:
jsr
apinit
jsr
grafhand
jsr
openwork
jsr
mouse_off
jsr
clwork
W
jsr
inlinea
loopl:
jsr
clwork
move. 1
ttextl,aO
jsr
printf
move.1
loopc,d7
loop2:
jsr
random
and. w
border,dO
move.w
dO, xO
jsr
random
and. w
border,dO
move. w
dO, yO
jsr
random
and. w
border,dO
move.w
dO, xl
jsr
random
and.w
border,dO
move.w
d0,yl
move.w
x0,d2
move.w
xl,a2
move.w
y0,d3
* Announce application
*
* Open screen work station
* Hide the Mouse
* Clear Display
* Color version only
* Address of text after AO
* Write text
* Generate random number
* bring to area 0-255
* through masking out of the upper
* 8 Bits of the lower word in DO
* transfer the two points to the
* "right" registers
101
ST 3D Graphics
Abacus Software
move.w
yl,a3
jsr
drawl
*
Draw line from XO,YO to XI,Y1 sketch
dbra
d7,loop2
*
Repeat loopc
jsr
inkey
*
Sense keyboard, do not wait for key
swap
dO
*
activation, scancode in DO
cmp. w
#$44,dO
*
compare with code in F10
bne
loopl
*
If not : loop again
rts
*
otherwise terminate program
***********************************************************************
* Call the operating system function for creation of a 4-byte integer*
* random number, the number is returned to DO. *
***********************************************************************
random: move.w #17,-(a7) * generate a 4-Byte Integer-
trap #14 * Random Number in DO. Use only
addq.l #2,a7 * the lower 2-Bytes
rts
.data
.even
**********************************************************************
* Variables for the Main program *
* *
**********************************************************************
**********************************************************************
* Text for the printf function, 27 Y 34 96 positions the cursor *
* Sequence is column, line, both with an offset of 32 *
**********************************************************************
text 1:
. dc -b
27, ' Y'
,40,42,
' Random lines ',0
loopc:
. dc. 1
60
*
Number of lines
border:
. dc. w
$ff
*
255 as display limit, with the high'
★
*
resolution B-W monitor the $ff
*
*
can be replaced with $lff = 511
102
Abacus Software
ST 3D Graphics
**********************************************************************
.bss
.even
x0:
.ds .w
1
* Temporary storage for the two
Y 0:
.ds.w
1
* Points, the program runs with small
xl:
• ds .w
1
* changes even without the intermediate
yl:
.ds.w
1
* storage; what changes ?
.end
103
Abacus Software
ST 3D Graphics
4. Graphics using assembly-language routines
The programs presented in the following part of the book can be used
with monochrome as well as color monitors, since the line drawing is
performed by the operating system, or to be more accurate, by the LINE-
A-routines. Of course it would be possible to convert the draw-line-
algorithm from the first link file for the various picture formats, but this
process has the disadvantage of requiring a subroutine for every picture
format. The programs described here can be executed on all kinds of
computer-monitor combinations. During program start, the main program
recognizes what type of monitor is attached and what resolution is desired
and on the basis of this information provides some variables with the
required data. For example, the coordinate origin of the picture system is
placed in the middle of the display. The larger memory capacity of the ST
permits it to handle significantly larger quantities of data. Once the
operating system of the smaller models is placed in ROM, the area
released in RAM will be sufficient even for the largest applications.
When calling the Metacombco Editor for input of the larger source files
(grlinkl, menul, rotatel, paintl) you have to specify
more memory space for listing to be entered along with the filename. To
do this, enter grlinkl. s 23000 in the dialog box that appears. This
reserves about 80k for the source text. If you enter source text without
comments the space reserved in the basic version of the editor should be
sufficient.
107
ST 3D Graphics
Abacus Software
4.1 Definition of a data structure for an object in space
The program modules presented here have the ability to represent on the
screen any object in a user defined world in any position, as seen from
various positions. The single disadvantage is the limitation of the valid
value range to ±32000; this means that for the definition of the world a
right angle three dimensional Cartesian coordinate system (right system)
is available whose three coordinate axes (X-Y-Z) are labeled with values
between +32000 and -32000. Whether these values are in meters,
kilometers or the number of corrupt politicians in the Senate depends on
the individual user and the application. For example, using the number of
corrupt politicians is a questionable value, since it changes from moment
to moment, and is far from constant.
Joking aside, a very simple object should suffice to describe the data
structure. We will use simple house as in Figure 4.1.1.
Figure 4.1.1: House as Wire Model
108
Abacus Software
ST 3D Graphics
Every object in the coordinate system is described through a finite
number of points and the lines which connect these points. To represent
the object, these points in the world system must be specified by
declaring of their coordinates. It has proved to be useful to define the
object, in this case the house, in its own coordinate system and to
transform it during the construction of the world coordinate system. To
gain an advantage, the coordinate origin of the object system is located
inside the house, if possible at a "rotationally neutral” point, i.e. during a
rotation of the object around this point, the maximum changes of the
individual points resulting from the rotation should be minimized. The
object should not be distorted.
Figure 4.1.2: House with coordinate system included
The individual steps during the "construction” of the house therefore are:
1. Draw a total view of the object (on a piece of paper) and
arbitrarily number of the individual points.
109
ST 3D Graphics
Abacus Software
Figure 4.1.3: House with numbered points
2. Draw the object in the various possible aspects with the current
coordinate axis for accurate specification of the points.
110
Abacus Software
ST 3D Graphics
Figure 4.1.4 - Figure 4.1.9: six views of the house
ill
ST 3D Graphics
Abacus Software
Figure 4.1.6
Figure 4.1.7
112
Abacus Software ST 3D Graphics
Figure 4.1.9
3. Set up a coordinate list of the individual points.
4. Create a line list, i.e. state which points are connected by
lines.
5. Indicate the number of points and lines in the object.
113
ST 3D Graphics
Abacus Software
Coordinate list of the house:
Point No.
X-coord.
Y-coord.
Z-coord.
1.
-30
30
60
2.
30
30
60
3.
30
-30
60
4.
-30
-30
60
5.
30
30
-60
6.
-30
30
-60
7.
-30
-30
-60
8.
30
-30
-60
9.
0
70
60
10.
0
70
-60
11.
-10
-30
60
12.
-10
0
60
13.
10
0
60
14.
10
-30
60
15.
30
20
40
16.
30
20
10
17.
30
0
10
18.
30
0
40
19.
30
20
-10
20.
30
20
-40
21.
30
0
-40
22.
30
0
-10
23.
30
-10
0
24.
30
-10
-20
25.
30
-30
-20
26.
30
-30
0
Total of 26 points.
114
Abacus Software
ST 3D Graphics
Line list:
Line No. from point to point
1.
1
2
2.
2
3
3.
3
4
4.
4
1
5.
2
5
6.
5
8
7.
8
3
8.
8
7
9.
7
6
10.
6
5
11.
6
1
12.
7
4
13.
9
10
14.
1
9
15.
9
2
16.
5
10
17.
6
10
18.
11
12
19.
12
13
20.
13
14
21.
15
16
22.
16
17
23.
17
18
24.
18
15
25.
19
20
26.
20
21
27.
21
22
28.
22
19
29.
23
24
30.
24
25
31.
25
26
32.
26
23
Total of 32 lines.
115
ST 3D Graphics
Abacus Software
Additional information on the object is required for the transformation of
the house into the world coorinate system: the angles housxw, housyw,
houszw, which describe a rotation of the house about one of the three
axes in regard to the coordinate origin, and the location of the house in
the world coordinate system. The location is the point to which the
coordinate origin (rotationally neutral point) of the house system is
displaced in the world system, housxO, housyO, houszO. In our first
example program the coordinate origin of the house system is moved to
the coordinate origin of the world system, housxO etc. and therefore
zero.
For further information, we need an observation point and a projection
center, where both points naturally are described in world coordinates. In
the simplest case the observation point is the coordinate origin point of
the world system, and the projection center [prox, proy, proz ] is
located on the positive Z axis of the world system. The system of the
observer (view system) is a right system in our programs and it is not
necessary to transform to a left system, to multiply all Z values by -1. For
our case this means that after transformation the view system a point with
the coordinates [ 10 , 10 ,- 300 ] is farther from the observer than a
point with the coordinates [10,10,-200].
Furthermore, we need the normal vector (direction vector) of the
projection plane. For simplification we assume that it is pointed from the
projection center toward the coordinate origin of the world system and
points toward the negative Z axis. The projection center lies on the Z axis
and therefore has the coordinates [0,0, proz ], since the normal vector
of the projection plane points in the direction of the negative Z axis, the
rotation of the observation direction vector to the negative Z axis is not
necessary.
To help explain the coordinate systems and viewing points, we have here
Figure 4.1.10 with the world system and the observation factors defined
in it.
116
Abacus Software
ST 3D Graphics
Figure 4.1.10
Summary:
To represent the house on the screen we need a total of four coordinate
systems, where the various coordinate systems exist only in theory and all
transformations occur in a single system. The defined points are stored in
arrays in which the various coordinate systems are then reflected so they
do not disappear after a transformation. The following coordinate systems
are used:
1. The data system (housdatx, housdaty,
housdatz), in which the house is defined at
construction.
2. The world system (wrldx, wrldy, wrldz), in which,
for example, a village is represented by several houses,
where the houses are all created by transformation at
various places in the world system from the one single
house defined in the data system.
117
ST 3D Graphics
Abacus Software
3. The view system (viewx, viewy, viewz), which is
used for the description of the view transformation. The
view transformation is the transformation into the observer
system, which is described through the observation
reference point and projection center as well as the vectors
from projection center to the observation reference. The
vector from the projection center to the observation
reference point is therefore the normal vector of the
projection plane.
4. The screen system has only two dimensions. The only
transformation which occurs in this system is shifting the
coordinate origin to any desired location with reversal of
the Y axis. Something we also used in our example is the
displacement to the screen center but other locations are
also possible depending on the application.
After this simplified observation situation, now an example for the
general view-transformation of a more complicated model. As a fictional
example we will use a world system which represents an airplane
standing on a runway. The observation point of the system should be in
the middle of the cockpit window, which is therefore the projection plane,
and the eye of the pilot should be the projection center. Let us also
imagine a tanker truck and an airplane hangar at some distance from the
airplane. Two types of transformations are possible.
1. A transformation of the object, which might mean that the
tanker truck moves and approaches the airplane, for
example. In this case the movement must occur in the
world system and only the coordinates of the tanker truck
need be recalculated in the world system.
118
Abacus Software
ST 3D Graphics
2. A movement of the observer, in this example the aiiplane.
Let’s go back to the starting position and assume that the
tanker truck remains in its original position. Now the
airplane should move, and for simulation of this
movement all objects in the world system, the tanker truck
and the hangar, must be transformed. The entire world
system would be rotated about the center of the cockpit
window. For a left rotation of the airplane, everything
must be rotated to the right. This connection can be easily
verified: If you move your head to the left, the observed
objects move to the right out of our field of view. When
the airplane is moved without rotation the observer gets
the impression of movement through the displacement of
the coordinate origin of the world system before the
projection.
3. A movement of the observer and the object, which means
first a transformation of the truck in the world system and
subsequent transformation of the total world system into
the view system.
Only after completion of these various cases do we get to the perspective
transformation, i.e the projection from space to the projection plane, or
more precisely into the screen. This was an example of a more complex
observation model.
You will probably ask why things have to be complicated by using an
additional coordinate system, the view system, when we could do
everything in the world system. This is true, but the addition of the view
system improves the accuracy and provides for a better overview of the
total system. Because of the rounding errors from the many
transformations, our world of the tanker truck and the hangar, would
according to the law of increasing entropy, degenerate to a chaotic mess
after a few hundred transformations. The aspect of the better overview is
at least as significant as the accuracy and I want to try to demonstrate this
fact again.
As you will see, all transformations can be carried out with a single
routine. Our application combines almost all of the rotations with matrix
multiplication and performs displacements before and after these
multiplications. The displacements are not included in the matrix
multiplications and our point coordinates are therefore not extended
119
ST 3D Graphics
Abacus Software
coordinates but consist only of the three coordinates [x,y,z] of the
current point. The only routine used is the rotation around any selected
point. As a reminder, during the rotation around any point, the coordinate
origin must first be moved to this point, then rotated by the desired angle
and finally the coordinate origin moved inverse to its original place by
back transformation. For the sequence of our routine this means that the
point about which rotation should occur is passed, also the rotation angles
around the corresponding axes (xw,yw,zw). The rotation routine first
calculates a multiplication matrix through multiplication of the rotation
matrixes belonging to the various angles. Then all points belonging to the
desired object [ x, y, z ] are manipulated in the following sequence:
1. The point [ x, y, z ] is moved to the rotation point. This is
achieved through subtraction of the coordinates of the
rotation point from the object coordinates. The result of
this operation is the point [ x', y', z' ].
2. The point [x', y' , z' ] is multiplied by the previously
calculated total rotation matrix.
Result: [x'' , y' ', z'' ].
3. The point is transformed back to the
"old" coordinate system by adding of the coordinates of
the rotation point
In this model the axes are not scaled. The size manipulation of the
objects, i.e. their pictured size on the screen, is performed during the
projection through movement of the projection plane. If different values
are selected for the subtraction occurring at the beginning and the
concluding addition, the movement of an observer in the world system is
simulated. If the angles of the normal surface vector in relation to the
world system are provided (in section 2.5 we calculated the angles
through projection on the various surfaces) the position of the observer
can be determined in space through one point and three angles.
Let us assume that a person is moving our world system, where the house
discussed in the first example is located at the coordinate origin. The eye
of this person, or actually the retina of the eye, is the projection plane. It
is irrelevant that the projection center in the human eye is in front of the
projection plane, since the reversed picture resulting from this is turned
around by the brain. For the simulation of this moving observer the
120
Abacus Software
ST 3D Graphics
coordinate origin of the world system must be moved to the center of the
retina, but we are limiting ourselves to a single eye. The coordinates of
the eye in the world system must be known; furthermore the head of the
observer can be moved through three different axis. You can easily
determine the axis yourself. The rotation about the first axis in our
coordinate system corresponds to the X axis, described by the observer
nodding his head up and down. The Y axis rotation is shaking his head.
The head rotates on the Z axis when the observer attempts to touch his ear
to his shoulder. If the three rotaion angles are known, the coordinate
origin will be rotated about this angle and the observed object lies in the
coordinate system of the observer. It is not necessary to reverse the
movement of the coordinate origin which is similar to the example of the
airplane.
In principle, an unlimited number of displacements, rotations, and
observer situations are possible: rotation of the house, rotation of the total
system around one point, or any axis, and also the displacement with
rotation into the observer system. To bring some order into this flood of
rotations, our programming examples are limited to one fixed observer
location point. This is no limitation on the observed effects on the screen
however, i.e. in principle it is the same whether one assumes that an
object rotated around a point, or the observer moved his head, provided
the size relationships are suitably adjusted. Finally, the programmer must
know the desired effect. There are many ways to achieve the same
effects.
And now, the description of the transformations of our data structure for
the first, fairly simple transformation program. The concrete object
(house) is defined in a coordinate system (housdatx, housdaty,
housdatz). During the initialization of the program, the subroutine
makewrld moves the house to any desired location in the world system
(wrldx, wrldy, wrldz), with possible rotation. In the first program it
is moved to the point [0,0,0] without rotation.
All further operations concerning the house relate only to the world
system. For example, the house can be rotated around any point of this
world system, or only the position of the house can be changed by
displacement. But now the initial scenario of our model changes through
these transformations, so we store the data for the rotation of the world
system in a new coordinate system (viewx, viewy, viewz), where
the initial scene (in wrldx, wrldy, wrldz) is available at any time
and can be reproduced at any time.
121
ST 3D Graphics
Abacus Software
After each operation in this world system, the coordinates of the
displaced house are stored in the view system. The object should also be
displayed on the screen. To do this, it must be adapted to the perspective
of the viewer situation. In our example, the projection center is at the
coordinates [0, 0, 1500]“therefore on the positive z axis of the right
handed coordinate system. Through the perspective transformation, the
coordinates of the view storage are transformed into screen coordinates
(screenx, screeny) whereby the desired location of the coordinate
origin and the orientation of the Y axis are considered during the
calculations. The screen coordinates are transferred with the aid of the
line list of the drawing routine, which, through the built-in "Cohen-
Sutherland clipper” draws only the desired screen area using the border
points clipule and cliplri (clip upper left, clip lower right). To
create some movement in this house, the rotation origin point or its
rotation angle can be changed slightly after each drawing and the whole
process can be programmed into a large loop for repeated execution.
In case you did not understand a few details, you can relax while typing
in the following program listings. You should consider that the material
discussed here corresponds to about a half a semester of lectures for
upper-class computer science students and therefore requires intense
consideration, even with the aid of the additional literature cited in the
beginning.
Just as in the first small program (random lines) this program is also
divided into a link file and main program. The new link file has the name
grlinkl. s and was enhanced with the sine and cosine routines, the
clip algorithm, the screen switch routine, the matrix operations and the
perspective transform routine. The main program housel.s contains
the data of the house and the main loop in which the rotation angles of the
house are changed in cycle and can be altered by the user. The steps for
creating a ready-to-run program are the same as in the third chapter. You
need only to replace basicl. s with grlinkl. s and mainl. s with
house 1. s in the command sequences. You should start typing in the
first program since the following programs build on the first two files.
That way you only have to type in the additional subroutines and data
sections. The link file grlinkl . s is the same for all following main
programs and does not have to be changed.
122
Abacus Software
ST 3D Graphics
***********************************************************************
* grlinkl.s Graphic Driver Version 4.0 *
* The main program must begin with the label " main *
***********************************************************************
***********************************************************************
* Global variables in the link files *
.globl drawl,sin,sincos,physbase
.globl logbase
.globl sinx,siny,sinz,cosx,cosy,cosz,wait
.globl waitl,drawnl
.globl pers,grafhand
•globl nummark,xangle,yangle,zangle,numline,datx,daty,datz
.globl pointx,pointy
.globl pointz,xplot,yplot,xO,yO,zO,zl,linxy,sincos
.globl grhandle,global,contrl,intin,intout,ptsin,ptsout
.globl addrin,addrout
.globl apinit,openwork,clwork,aes,vdi
.globl rotate,dist,zobs
.globl matrixll,matrixl2,matrixl3
.globl matrix21,matrix22,matrix23
.globl matrix31,matrix32,matrix33
.globl xrotate,yrotate,zrotate,matinit,inkey
.globl mouse_on,mouse_off,printf
.globl clipxule,clipyule,clipxlri,clipylri
.globl filstyle,filindex,filform,filcolor,filmode,yrot
.globl lineavar,pageup,pagedown,plotpt
123
ST 3D Graphics
Abacus Software
********************************************************************
* Program initialization and storage requirement calculations *
********************************************************************
.text
sstart:
move.1
a7, a5
*
Base page address on the stack
move.1
4 (a5),a5
*
basepage address = program start - $100
move.1
$c(a5),dO
*
Program length
add. 1
$14(a5),dO
*
Length of initialized data area
add. 1
$lc{a5),d0
*
Data area not initialized
add. 1
#$1100,dO
*
4 K-byte user stack
move.1
a5, dl
*
Start address of the program
add. 1
dO, dl
*
Plus number of occupied bytes = space requirement
and. 1
#-2,dl
*
Even address for stack
move.1
dl, a 7
*
User stack pointer to last 4K- byte
move.1
dO,-(sp)
*
Length of reserved area
move.1
a5,-(sp)
*
Beginning address of reserved area
move.w
dO, -(sp)
*
Dummy-word
move.w
#$4a,-(sp)
*
GEM DOS function SETBLOCK
trap
#1
add. 1
#12,sp
*
Restore old stack address
jsr
startl
*
Check on display address
jsr
inlinea
*
Initialize Line-A routines
jsr
main
*
Jump to main program (user-created)
move.1
#0,- (a7)
*
End current program
trap
#1
*
Back to Gem desktop
***********************************************************************
* Pass upper screen page to video controller *
* while drawing the other *
***********************************************************************
pageup:
move.w
#-l,-(a7)
move.1
physbase,-(a7)
* Page
displayed
move.1
logbase,- (a7)
* Draw
on this page
move.w
#5,- (a7)
trap
add. 1
#12,a7
rt s
124
Abacus Software
ST 3D Graphics
***********************************************************************
* Display screen page at lower address, while all drawing *
* operations after the call go to the higher display *
***********************************************************************
pagedown: move.w
#-l,-(a7)
move.1
logbase,- (a7)
* display logical page
move.1
physbase,-<a7)
* draw in the other one
move. w
#5,-(a7)
trap
Pb
add. 1
#12,a7
rts
***********************************************************************
* This subroutine calls AES functions, the user must *
* save the Registers D0-D2 and A0-A2 before the aes call, *
* which are used by VDI and AES *
***********************************************************************
aes:
move.1
move.w
trap
rts
#aespb,dl
#$c8,dO
dp
* call the AES functions
* call the VDI functions *
vdi:
move.l #vdipb,dl * call the VDI functions
move.w #$73,dO
trap (^#2^?
rts
125
ST 3D Graphics
Abacus Software
***********************************************************************
* initialize the Line-A functions, pass the address of *
* Line-A variable area in AO, which is then stored *
* in lineavar *
***********************************************************************
.dc.w
$a000
move.1
aO,lineavar
move. w
#0,32(aO)
move.w
#$ffff,34(aO)
move.w
#0,36 (aO)
move.w
rts
#1,24 <a0)
* announces application *
apinit:
clr. 1
dO
move. 1
dO,aplresv
move.1
dO,ap2resv
move.1
dO,ap3resv
move.1
dO,ap4resv
move.w
#10,opcode
move.w
#0,sintin
move.w
#1,sintout
move.w
#0,saddrout
move.w
#0,saddrin
jsr
aes
rts
* announces an application
A**********************************************************************
* Transfers desktop screen handler to caller *
***********************************************************************
grafhand:
move.w #77,contrl
move.w #0,contrl+2
move.w #5,contrl+4
move.w #0,contrl+6
move.w #0,contrl+8
* Transfer screen handler
126
Abacus Software
ST 3D Graphics
jsr aes
move.w intout,grhandle
rts
* open a workstation *
openwork: move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move.w
move„w
jsr
rts
#100,opcode
#1, dO
#0,contrl+2
#11,contrl+6
grhandle,contrl+12
dO,intin
dO,intin+2
dO,intin+4
dO,intin+6
dO,intin+8
dO,intin+10
dO,intin+12
dO,intin+14
dO,intin+16
dO,intin+18
#2,intin+20
vdi
* opens a workstation
* Clear the screen
clwork:
move.w
#3,contrl
move.w
#0,contrl+2
move.w
#1,contrl+6
move.w
grhandle,contrl+12
jsr
vdi
rts
* clear screen VDI function
127
ST 3D Graphics
Abacus Software
* Enable mouse *
mouse on:
move.w
#122,contrl
* enable mouse
move. w
#0,contrl+2
* and control with
move. w
#1,contrl+6
* operating system
move.w
grhandle,contrl+12
move.w
#0,intin
jsr
vdi
rts
* Disable mouse *
mouse off:
move.w
#123,contrl
* Disable mouse
move. w
#0,contrl+2
* and control
move.w
#0,contrl+6
move.w
grhandle,contrl+12
jsr
vdi
rts
* write string on screen *
printf:
move.1
move.w
trap
addq.1
rt s
aO,-(a7)
#9,-(a7)
#1
#6,a7
* write a string
* whose starting
* is in AO, on the
* screen. String
* must end with a zero.
* Determine screen address *
start 1:
move.w #2,-{a7)
trap #14
addq.1 #2,a7
* Determine the screen
* address of the system
* which computer ?
128
Abacus Software
ST 3D Graphics
move. 1
sub. 1
move.1
rts
dO,physbase * screen start minus 32 K-byte
#$8000,dO
dO,logbase * equals logical display page
************************************************************************
* Plot routine x-coordinate in d2, y-coordinate in d3 *
************************************************************************
plotpt:
movem.1
dO-d2/aO-a2,
- (a7)
t st. w
d2
* X-value
less than zero =>
bmi
stop2
tst. w
d3
* Y-value
less zero
bmi
stop2
cmp.w
#639,d2
* X-value
greater than 639?
bhi
stop2
* Display
limit
cmp.w
#399,d3
* Y-value
greater than 399?
bhi
stop2
move .w
d2,ptsin
move. w
d3,ptsin+2
move. w
#1,intin
.dc. w
$a001
movem. 1
(a7) +,d0-d2/a0-a2
stop2:
rts
**********************************************************************
* draw-line routine with Cohen-Sutherland clipping. The points are *
* passed in d2, d3 (start point) and a2, a3 (end point)
**********************************************************************
drawl:
movem.1
d0-d7/a0-a6,-(a7)
move.w
d2,d6
move.w
d3,d7
jsr
rel_pos
move.w
dl,codel
move.w
a2,d6
move.w
a3,d7
jsr
rel_pos
move.w
dl,code2
tst. w
dl
bne
testwl
* Save registers
* Determine position
* of start point and
* store
* Position of second
* point and store
* if points are not in
* drawing area continue
129
ST 3D Graphics
Abacus Software
*
testwl:
testw2:,
testw3:
tst. w
codel
*
test. Otherwise test
beq
drawit2
*
first point. When visible.
*
draw both points
move.w
dl, dO
*
If both points on the same
and. w
codel,dO
*
'page' outside the viewing
bne
drawend
*
window, then do not draw.
move.w
d2,a0
*
else store starting points and
move.w
d3, al
*
calculate intersecting points
move.w
a2, a4
move.w
a3, a5
tst.w
code2
*
is point 2 visible ?
bne
testw2
*
if not, find intersection point
move.w
a2,rightx
*
if yes, store
move. w
a3,righty
bra
testw3
*
find left intersect point
move.w
codel,plcode
*
right intersect point
move.w
code2,p2code
jsr
fndpoint
*
find intersect point
tst. w
plcode
*
if 'intersect point'not
bne
drawend
*
visible, then end
move.w
d2,rightx
*
if visible, then store
move.w
d3,righty
move.w
a4,d2
*
and the left intersect point
move. w
a5, d3
*
with switched points
move.w
aO, a2
*
determine with the same routine
move.w
al, a3
move.w
code2,plcode
move.w
codel,p2code
tst. w
p2code
★
Point visible?
bne
testw4
*
if not, continue test
move.w
a2,leftx
★
if yes, store and
move. w
a3,lefty
*
connect both visible
bra
drawitl
*
points with a line
130
Abacus Software
ST 3D Graphics
testw4:
jsr
fndpoint
★
Find intersect point
move. w
d2,leftx
★
and store.
move. w
d3,lefty
drawitl:
move. w
leftx,d2
*
connect both points with
move. w
lefty,d3
*
a line
clr. 1
a2
clr. 1
a3
move. w
rightx,a2
move.w
righty,a3
drawit2:
move.1
lineavar,aO
move. w
d2,38 <a0)
*
XI
move.w
d3,40 (aO)
★
Y1
move.w
a2,42(aO)
*
X2
move.w
a3,44(aO)
*
Y2
.dc .w
Sa003
*
Draw line
drawend:
endit:
movem.1
(a7)+,d0-d7/a0-a6
★
Restore registers
rts
*
Return to calling program
**********************************************************************
* recognizes the position of a point passed in D6 and D7 relative *
* to the clip window defined in the variables clipoli and clipure *
**********************************************************************
clr. 1
dl
*
determines the position
move. w
d7,dl
*
of the point passed in
sub. w
clipyule,dl .
*
d6 and d7 relative to
lsl.l
#1, dl
*
the drawing window
move.w
d7, dl
*
defined by clipure
sub. w
clipylri,dl
*
and clipoli
neg. w
dl
lsl.l
#1, dl
move.w
d6, dl
sub. w
clipxlri,dl
neg. w
dl
lsl.l
#1, dl
move.w
d6, dl
sub. w
clipxule,dl
lsl.l
#1, dl
131
ST 3D Graphics
Abacus Software
swap dl
rts
**********************************************************************
* Finds the intersect point, if present, *
* of the the connecting line from Pi to P2 with the clip window *
* the points are passed in D2, D3 and A2, A3 as in drawl *
**********************************************************************
fndpoint:
findwl:
move.w
d2,d4
*
Find the center point of
move. w
d3,d5
*
the line PI P2
add. w
a2,d4
*
{XI + X2) / 2
ext .1
d4
lsr. 1
#l,d4
add. w
a3,d5
*
(Y1 + Y2) / 2
ext .1
d5
*
= center point of line PI P2
lsr. 1
#l,d5
move.w
d4,d6
*
Store center point coord.
move.w
d5,d7
*
Y middle
jsr
rel_pos
*
where is the intersect point
move.w
p2code,d6
*
Code of center pt. to D6
and.w
dl, d6
*
are the points on the same
bne
fother
*
page outside the screen
cmp. w
d4,d2
*
points coincide ?
bne
findwl
cmp.w
d5,d3
beq
fendit
*
if yes => stop
cmp. w
d4, a2
*
Do middle point and second
bne
findw2
*
point match ?
cmp. w
d5,a3
bne
findw2
bra
fendit
*
if yes = stop
?
132
Abacus Software
ST 3D Graphics
f indw2:
move. w
d4,d2
*
else exchange middle and
move. w
d5,d3
*
first point and start again
move. w
dl,plcode
bra
fndpoint
fother:
cmp - w
d4,a2
*
middle point and P2 match ?
bne
fotherl
cmp. w
d5, a3
beq
fendit
*
if yes, then end
fotherl:
cmp. w
d4,d2
*
middle point and PI match ?
bne
fother2
cmp. w
d5,d3
beq
fendit
*
if yes, then end
fother2:
tst. w
plcode
★
is Pl in clip window
beq
fother3
move.w
dl,d7
*
if not, and Pl and P2 lie
and. w
plcode,d7
*
both on one side of the
bne
fexit
*
Clip-window then none of line
is visible
fother3:
move.w
d4,a2
*
otherwise take middle point
move.w
d5,a3
*
as new P2 and start again
move.w
dl,p2code
*
until the intersect point
bra
fndpoint
*
is found
fexit:
move.w
#1,plcode
*
Inform calling prog, of termination.
fendit:
rts
*
either in d2,d3 middle point.
or
*
*
in plcode termination notice
******************************************************************
* sine and cosine Function, angle is passed in DO and
* the sine and cosine are returned in Dl and D2 *
******************************************************************
tst. w
dO
*
Angle negative, add 360 degrees
bpl
noaddi
add.w
#360,dO
move.1
#sintab,al
★
Beginning address of sine £able
move. 1
d0,d2
*
Angle in dO and d2
lsl. w
#1, dO
*
Angle times two as index for access
move.w
0 (al,dO.w),dl
*
sine to dl
133
ST 3D Graphics
Abacus Software
cmp. w
#270,d2
bit
plus9
sub. w
#270,d2
bra
sendsin
plus9:
add.w
#90,d2
sendsin:
lsl. w
#l,d2
move.w
0 (al,d2.w) ,d2
rt s
* Calculate cosine through
* displacement of sine values
* by 90 degrees
* cosine to d2
*
* and back to calling program
* sine function *
* Angle is passed in dO and the sine returned in dl *
sin:
move. 1
#sintab,al
t st • w
dO
bpl
sinl
add.w
#360,dO
sinl:
lsl. w
#1, dO
move.w
rts
0(al,dO.w)
************************************************************************
* Initialize the main diagnonal of the result matrix with *
* ones which were multiplied by 2 A 14. This subroutine must *
* be called at least once before the call by rotate, or the *
* result matrix will only consist of zeros. *
★★★★A*******************************************************************
move.w
#0, dl
move.w
#16384,d2
*
The
initial value for
move.w
d2,matrixll
*
the
main diagonal of
move.w
dl,matrixl2
*
the
result matrix
move.w
dl,matrixl3
*
all
other elements
move.w
dl,matrix21
★
at zero
move. w
d2,matrix22
move.w
dl,matrix23
move.w
dl,matrix31
move . w
dl,matrix32
134
Abacus Software
ST 3D Graphics
move.w d2,matrix33
rts
************************************************************************
* Multiplication of the rotation matrix by the rotation
* matrix for rotation about the X-axis
************************************************************************
xrotate:
move. w
xangle,dO
jsr
sincos
move.w
dl,sinx
move. w
d2,cosx
move.w
dl, d3
move.w
d2,d4
move.w
matrixll,rotxll
move.w
matrix21,rotx21
move.w
matrix31,rotx31
muls
matrixl2,d2
mu Is
matrixl3,dl
sub. 1
dl, d2
lsl.l
#2,d2
swap
d2
move. w
d2,rotxl2
move. w
d3, dl
move. w
d4,d2
muls
matrix22,d2
muls
matrix23,dl
sub. 1
dl, d2
lsl.l
'#2,d2
swap
d2
move.w
d2,rotx22
move.w
d3,dl
move.w
d4,d2
muls
matrix32,d2
muls
matrix33,dl
sub. 1
dl, d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotx32
move.w
d3, dl
* multiply matrixll-matrix33
* with the rotation matrix for a
* rotation about the X-axis
* The first column of the matrix
* does not change with X rotation
135
ST 3D Graphics
Abacus Software
move. w
d4,d2
mu Is
matrixl2,dl
mu Is
matrixl3,d2
add. 1
dl, d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotxl3
move. w
d3, dl
move. w
d4,d2
mu Is
matrix22,dl
mu Is
matrix23,d2
add. 1
dl, d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotx23
muls
matrix32,d3
mu Is
matrix33,d4
add. 1
d3,d4
lsl.l
#2,d4
swap
d4
move.w
d4,rotx33
move. 1
irotxll,al
move.1
#matrixll,a2
move.1
#9,d7
* Number of matrix elements
subq.1
#1, d7
rotxlopl’: move. w
(al)+, (a2) +
* Copy result matrix.
which
dbra
d7,rotxlopl
* is still in ROTXnn,
to MATRIXnn
rts
***********************************************************************
* multiply the general rotation matrix by the Y-axis *
* rotation matrix. Results are stored in the general *
* rotation matrix *
***********************************************************************
move. w
yangle,dO
* Angle around which
jsr
sincos
move .w
dl,siny
move.w
d2,cosy
move.w
dl, d3
* Sine of Y-angle
move.w
d2,d4
* Cosine of Y-angle
136
Abacus Software
ST 3D Graphics
mu Is
matrixll,d2
mu Is
matrixl3,dl
add. 1
dl, d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotxll
move.w
d3, dl
move.w
d4, d2
mu Is
matrix21,d2
mu Is
matrix23,dl
add. 1
dl,d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotx21
move.w
d3,dl
move.w
d4, d2
muls
matrix31,d2
muls
matrix33,dl
add. 1
dl, d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotx31
neg.w
d3
move. w
d3, dl
* -siny in the rotation matrix
move .w
d4,d2
move. w
matrixl2,rotxl2
move. w
matrix22,rotx22
* The second column
move. w
matrix32,rotx32
* of the starting
muls
matrixll,dl
* matrix does not
muls
matrixl3,d2
* change
add. 1
dl, d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotxl3
move.w
d3,dl
move.w
d4,d2
muls
matrix21,dl
muls
matrix23,d2
add. 1
dl,d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotx23
137
ST 3D Graphics
Abacus Software
muls
matrix31,d3
muls
matrix33,d4
add. 1
d3,d4
lsl.l
#2,d4
swap
d4
move.w
d4,rotx33
move.1
#8, d7
move.1
#rotxll,al
move.1
#matrixll,a2
yrotlopl: move.w
(al)+, <a2)+
dbra
d7,yrotlopl
rts
* Address of result matrix
* Address of original matrix
* Copy result matrix
* to the original matrix
* 2-axis - Rotation matrix multiplications *
move.w
zangle,dO
jsr
sincos
move.w
dl,sinz
move.w
d2,cosz
move.w
dl,d3
move.w
d2, d4
muls
matrixll,d2
muls
matrixl2,dl
sub. 1
dl, d2
lsl.l
#2,d2
swap
d2
move.w
d2,rotxll
move.w
d3, dl
move.w
d4,d2
muls
matrix21,d2
muls
matrix22,dl
sub. 1
dl, d2
lsl.l
#2,d2
swap
d2
move. w
d2,rotx21
move. w
d3, dl
move.w
d4,d2
muls
matrix31,d2
muls
matrix32,dl
sub. 1
dl, d2
138
Abacus Software
ST 3D Graphics
zrotlopl
lsl.1
#2,d2
swap
d2
move.w
d2,rotx31
move.w
d3, dl
move.w
d4, d2
mu Is
matrixll,dl
mu Is
matrixl2,d2
add. 1
dl,d2
lsl.l
#2, d2
swap
d2
move.w
d2,rotxl2
move.w
d3, dl
move. w
d4,d2
mu Is
matrix21,dl
mu Is
matrix22,d2
add. 1
dl, d2
lsl.l
#2, d2
swap
42
move. w
d2,rotx22
mu Is
matrix31,d3
mu Is
matrix32,d4
add. 1
d3,d4
lsl.l
#2,d4
swap
d4
move.w
d4,rotx32
move. w
matrixl3,rotxl3
*
the third column
move.w
matrix23,rotx23
*
remains
move.w
matrix33,rotx33
*
unchanged
move . 1
#8,d7
move.1
trotxll,al
move.1
#matrixll, a2
: move.w
(al)+,(a2)+
*
copy to general
dbra
d7, zrotlopl
*
rotation matrix
rts
139
ST 3D Graphics
Abacus Software
* Multiply every point whose Array address is in datx etc. *
* by previous translation of the coordinate source to *
* point [offx,offy,offz], with the general rotation matrix. *
* The coordinate source of the result coordinates is then *
* moved to point [xoffs,yoffs,zoffs] *
rotate:
rotatel:
move.w
nummark,dO
* Number of points to be
ext. 1
dO
* transformed as counter
subq.1
#1, dO
move.1
datx,al
move.1
daty,a2
move.1
datz,a3
move.1
pointx,a4
move.1
pointy,a5
move.1
pointz,a6
move.w
(al)+,dl
* X-coordinate
add.w
offx,dl
move.w
dl, d4
move.w
(a2)+,d2
* Y-coordinate
add.w
offy,d2
* Translation to point [offx,offy,offz]
move.w
d2,d5
move.w
(a3)+,d3
* Z-coordinate
add.w
offz,d3
move.w
d3,d6
muls
matrixll,dl
mu Is
matrix21,d2
muls
matrix31,d3
add. 1
dl, d2
add. 1
d2,d3
lsl.l
#2,d3
swap
d3
add.w
xoffs,d3
move. w
d3,(a4)+
* rotated X-coordinate
move. w
d4, dl
move.w
d5,d2
move.w
d6,d3
muls
matrixl2,dl
Abacus Software
ST 3D Graphics
mu Is
matrix22,d2
mu Is
matrix32,d3
add. 1
dl,d2
add. 1
d2,d3
lsl.l
#2,d3
swap
d3
add. w
yoffs,d3
move . w
d3,(a5)+
mu Is
matrixl3,d4
mu Is
matrix23,d5
mu Is
matrix33,d6
add. 1
d4,d5
add. 1
d5, d6
lsl.l
#2,d6
swap
d6
add. w
zoffs,d6
move. w
d6,(a6)+
dbra
rts
dO,rotatel
* rotated Y-coordinate
* rotated Z-coordinate
************************************************************************
* Perspective, calculated from the transformed points in the arrays *
* pointx, pointy an d point z the screen coordinates, which *
* are then stored in the arrays xplot and^plot . *
************************************************************************
move. 1
pointx,al
*
Beginning address of
move. 1
pointy,a2
*
Point arrays
move.1
pointz,a3
move.1
xplot,a4
*
xplot contains start address of the
move.1
yplot,a5
*
display coordinate array
move.w
nummark,dO
*
Number of points to be transformed
ext .1
dO
*
as counter
subq.1
#1, dO
move.w
(a3)+, d5
★
z-coordinate of object
move.w
d5,d6
move. w
dist,d4
*
Enlargement factor
sub. w
d5,d4
★
dist minus Z-coordinate of Obj.coord
141
ST 3D Graphics
Abacus Software
persl:
perendl:
ext. 1
d4
lsl.l
#8,d4
* times 256 for value fitting
move. w
zobs,d3
* Projection center Z-coordinates
ext. 1
d3
sub. 1
d6,d3
* minus Z-coordinate of object
bne
persl
move. w
#0, dl
* Catch division by zero
addq.1
#2,al
* Not really required since
addq.1
#2,a2
* computer catches this
move.w
dl,(a4)+
* with an interrupt
move.w
dl,(a5)+
bra
perendl
divs
d3,d4
move.w
d4,d3
move.w
(al)+,dl
*
X-coordinate of object
move.w
dl,d2
neg. w
dl
muls
dl,d3
*
multiplied by perspective factor
lsr.l
#8,d3
★
/256 save value range fitting
add.w
d3,d2
*
add to X-coordinate
add.w
x0,d2
*
add screen offset (center point)
move. w
d2,(a4)+
*
Display X-coordinate
move.w
(a2)+,dl
*
Y-coordinates of object
move.w
dl, d2
neg. w
dl
muls
dl, d4
lsr. 1
#8,d4
*
/256
add. w
d4,d2
neg. w
d2
*
Display offset, mirror of Y-axis
add.w
y0,d2
*
Source at [XO,YO]
move.w
d2,(a5)+
*
Display Y-coordinate
dbra
dO, perlop
*
All points transformed ?
rt s
★
If yes, return
142
Abacus Software
ST 3D Graphics
•dr*****************************************************************
* Draw number of lines from array from lines in linxy *
******************************************************************
drawnl:
drlop:
move.1
xplot,a4
*
Display X-coordinate
move.1
yplot,a5
*
" Y-coordinate
move. w
numline,dO
*
Number of lines
ext .1
dO
subq.1
#1, dO
*
as counter
move.1
linxy,a6
*
Address of line array
move.1
(a6) +,dl
*
first line , (PI,P2)
subq.w
#l,dl
*
fit to list structure
lsl.w
#1, dl
*
times list element length (2)
move.w
0(a4,dl.w),d2
*
X-coordinate of second point
move.w
0(a5,dl.w),d3
*
Y-coordinate of second point
swap
dl
*
same procedure for first point
subq.w
#1, dl
lsl.w
#1, dl
move.w
0(a4,dl.w),a2
*
X-coordinate of first point
move.w
0(a5,dl.w),a3
*
Y-coordinate of first point
jsr
drawl
*
draw line from P2 to P2
dbra
dO,drlop
*
All lines drawn ?
rts
***********************************************************************
* simple counting loop *
***********************************************************************
waitl dbra dO,waitl * delay loop, counts dO register
rts * down to -1
***********************************************************************
* wait for key press, for Test and Error detection *
***********************************************************************
wait: move.w #l,-(a7) * wait for key activation
trap #1 * GEM DOS call
addq.l #2,a7
rts
143
ST 3D Graphics
Abacus Software
***********************************************************************
* Key sensing, ASCII code returned in lower byte word of DO *
* Scan code in upper sord lower byte of DO *
* Returns zero if no input *
***********************************************************************
move.w
#2,-(a7)
* Key sensing, does not
move.w
#1,- (a7)
* wait for a key
trap
#13
* press
addq.1
#4, a7
tst. w
dO
bpl
endkey
move.w
#7,-{a7)
trap
#1
addq.1
#2,a7
endkey: rts
** The six following subroutines are only required **
** for the second main program and do not have to be **
** entered for linking to the first main program **
filstyle:
filindex:
move. w
#23,contrl
*
VDI function, set
move.w
#0,contrl+2
*
fill style passed
move. w
#1,contrl+6
★
in DO
move. w
grhandle,contrl+12
move. w
dO,intin
jsr
vdi
rts
movem.1
dO-d2/aO-a2,- (a7)
*
set fill pattern
move. w
#24,contrl
*
also passed in DO
move.w
#0,contrl+2
move.w
#1,contrl+6
move -w
grhandle,contrl+12
move.w
dO,intin
144
Abacus Software
ST 3D Graphics
filcolor:
filmode:
filform:
jsr
vdi
raovera.1
{a 7)+ ,d0-d2/a0-a2
rts
move. w
#25,contrl
move. w
#0,contrl+2
move. w
#1,contrl+6
move.w
grhandle,contrl+12
move.w
#1,intin
jsr
vdi
rts
move.w
#32,contrl
move.w
#0,contrl+2
move.w
#1,contrl+6
move.w
grhandle,contrl+12
move.w
dO,intin
jsr
vdi
rts
move. w
#104, contrl
move.w
#0, contrl + 2
move.w
#1,contrl+6
move.w
grhandle,contrl+12
move.w
#1,intin
jsr
vdi
rts
* set fill color to
* one
* set write mode
* passed in DO
* switch on border
* around area
*********************************************************************
* Rotation of a number of points (nummark) in array datx etc. around*
* angle yangle around Y-axis to array pointx = address of array *
*********************************************************************
move.w
yangle,dO
*
rotate the definition line
jsr
sincos
*
of a rotation body nummark
move. w
dl,siny
*
times about the Y-axis
move.w
d2,cosy
*
Rotation is done without
move.1
datx,al
*
matrix multiplication.
move.1
daty,a2
*
but directly, from arrays datx
move.1
datz,a3
*
in which the address of the definition
move.1
pointx,a4
*
line was stored into the array
145
ST 3D Graphics
Abacus Software
move.1
pointy,a5
* whose address is stored
move.1
pointz,a6
* in pointx etc.
move . w
nummark,dO
ext. 1
dO
* the rotation is about
subq.1
#1, dO
* angle -y, i.e. from direct:
move.w
(al)+,dl
* positive Y-axis
move.w
dl,d3
* counterclockwise
move.w
(a3)+,d2
move.w
d2,d4
* z' = x*siny + z*cosy
mu Is
cosy,d2
lsl.l
#2, d2
* retract area extension
swap
d2
* sine values
mu Is
siny,dl
lsl.l
#2, dl
swap
dl
add. w
dl,d2
move. w
d2,(a6)+
* store z'
mu Is
siny,d4
* calculate x'
lsl.l
#2,d4
* x' = x*cosy - z*siny
swap
d4
neg. w
d4
mu Is
cosy,d3
lsl.l
#2,d3
swap
d3
add. w
d3,d4
move.w
d4, (a4) +
* store x'
move.w
(a2) +, (aS) +
* y' = y, since rotation is
dbra
dO,ylop
* around Y-axis
rts
* Variables for the basic program *
• even
.data * Sine table starts here
sintab: .dc.w
.dc. w
. dc. w
0,286,572,857,1143,1428,1713,1997,2280
2563,2845,3126,3406,3686,3964,4240,4516
4790,5063,5334,5604,5872,6138,6402,6664
146
Abacus Software
ST 3D Graphics
.dc.w
. dc. w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
• dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
-dc.w
• dc.w
• dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc. w
.dc.w
.dc.w
.dc.w
.dc.w
• dc.w
.dc.w
.dc.w
.dc.w
6924,7182,7438,7692,7943,8192,8438,8682
8923,9162,9397,9630,9860,10087,10311,10531
10749,10963,11174,11381,11585,11786,11982,12176
12365,12551,12733,12911,13085,13255,13421,13583
13741,13894,14044,14189,14330,14466,14598,14726
14849,14962,15082,15191,15296,15396,15491,15582
15668,15749,15826,15897,15964,16026,16083,16135
16182,16225,16262,16294,16322,16344,16362,16374
16382,16384
16382,16374,16362,16344,16322,16294,16262,16225
16182
16135,16083,16026,15964,15897,15826,15749,15668
15582,15491,15396,15296,15191,15082,14962,14849
14726,14598,14466,14330,14189,14044,13894,13741
13583,13421,13255,13085,12911,12733,12551,12365
12176,11982,11786,11585,11381,11174,10963,10749
10531,10311,10087,9860,9630,9397,9162,8923
8682,8438,8192,7943,7692,7438,7182,6924
6664,6402,6138,5872,5604,5334,5063,4790
4516,4240,3964,3686,3406,3126,2845,2563
2280,1997,1713,1428,1143,857,572,286,0
-286,-572,-857,-1143,-1428,-1713,-1997,-2280
-2563,-2845,-3126,-3406,-3686,-3964,-4240,-4516
-4790,-5063,-5334,-5604,-5872,-6138,-6402,-6664
-6924,-7182,-7438,-7692,-7943,-8192,-8438,-8682
-8923,-9162,-9397,-9630,-9860,-10087,-10311,-10531
-10749,-10963,-11174,-11381,-11585,-11786,-11982
-12176
-12365,-12551,-12733,-12911,-13085,-13255,-13421
-13583
-13741,-13894,-14044,-14189,-14330,-14466,-14598
-14726
-14849,-14962,-15082,-15191,-15296,-15396,-15491
-15582
-15668,-15749,-15826,-15897,-15964,-16026,-16083
-16135
-16182,-16225,-16262,-16294,-16322,-16344,-16362
-16374,-16382,-16384
147
ST 3D Graphics
Abacus Software
.dc.w
-16382,-16374,-16362,-16344,
-16322,-16294,'
-16262
. dc. w
-16225,-16182
.dc.w
-16135,-16083,-16026,-15964,
-15897,-15826,
-15749
.dc. w
-15668
.dc. w
-15582,-15491,-15396,-15296,
-15191,-15082,
-14962
• dc. w
-14849
. dc. w
-14726,-14598,-14466,-14330,
-14189,-14044,
-13894
.dc.w
-13741
. dc. w
-13583,-13421,-13255,-13085,
-12911,-12733,
-12551
.dc.w
-12365
.dc.w
-12176,-11982,-11786,-11585,
-11381,-11174,
-10963
.dc.w
-10749
.dc.w
-10531,-10311,-10087,-9860,-
9630,-9397,-9162,-8923
.dc.w
-8682,-8438,-8192,-7943,-7692,-7438,-7182,
-6924
.dc.w
-6664,-6402,-6138,-5872,-5604,-5334,-5063,
-4790
.dc.w
-4516,-4240,-3964,-3686,-3406,-3126,-2845,
-2563
.dc.w
-2280,-1997,-1713,-1428,-1143,-857,-572,-286,0
.even
• bss
xO:
• ds. w
1
* Position of the coordinate origin on
o
>
• ds. w
1
* the screen
zO:
.ds. w
1
zl:
.ds. w
1
linxy
.ds. 1
1
* This is the address of the line array
nurrmark:
. ds. w
1
* Number of points
numline:
-ds. w
1
* Number of lines
pointx:
. ds. 1
1
* Variables of point arrays for world,
pointy:
.ds. 1
1
* view, and screen coordinates
pointz:
• ds. 1
1
xplot
.ds.l
1
yplot
.ds. 1
1
datx:
.ds.l
1
daty:
.ds.l
1
datz:
.ds.l
1
148
Abacus Software
ST 3D Graphics
sinx:
.ds.w
1
* Temporary storage for sine and
sinz:
.ds.w
1
* cosine values
siny:
.ds.w
1
cosx:
.ds.w
1
cosz:
.ds.w
1
cosy:
.ds.w
1
varl:
.ds.w
1
* general variables
var2:
.ds.w
1
var3:
.ds.w
1
xangle:
.ds.w
1
* Variables for passing angles
yangle:
. ds . w
1
* to the rotation subroutine
zangle:
.ds.w
1
physbase:
-ds. 1
1
* Address of first screen page
logbase:
.ds. 1
1
* Address of second screen page
contrl:
opcode:
.ds.w
1
* Arrays for AES and VDI functions
* for passing parameters
sintin:
.ds.w
1
sintout:
.ds.w
1
saddrin:
.ds.w
1
saddrout:
.ds.w
1
.ds.w
6
global:
apversion:
.ds.w
1
apcount:
.ds.w
1
apid:
.ds.w
1
apprivate:
• ds. 1
1
apptree:
.ds. 1
1
aplresv:
.ds. 1
1
ap2resv:
.ds. 1
1
ap3resv:
. ds . 1
1
ap4resv:
. ds. 1
1
intin:
• ds.w
128
ptsin:
.ds.w
256
intout:
.ds.w
128
149
ST 3D Graphics
Abacus Software
ptsout:
.ds. w
128
addrin:
.ds. w
128
addrout:
. ds. w
128
grhandle:
.ds. w
1
lineavar:
.ds. 1
1 * Starting address of Line-A var
. data
vdipb:
.dc. 1
contrl,intin,ptsin,intout,ptsout
aespb:
. dc. 1
contrl,global,intin,intout,addrin,addrout
leftx:
.dc. w
0
lefty:
.dc.w
0
rightx:
.dc. w
0
righty:
. dc. w
0
plcode:
.dc.w
0
p2code:
.dc. w
0
codel:
.dc.w
0
code2:
.dc.w
0
mid_code:
.dc.w
0
clipxule:
.dc.w
0 * Clip window variables
clipyule:
.dc.w
0
clipxlri:
.dc.w
639
clipylri:
.dc.w
399
dist:
.dc.w
0
zobs:
.dc.w
1500
rotxll:
.dc.w
16384 * Space here for the result matri
rotxl2:
.dc.w
0 * matrix multiplication
rotxl3:
.dc.w
0
rotx21:
.dc.w
0
rotx22:
.dc.w
16384
rotx23:
.dc.w
0
rotx31:
.dc.w
0
rotx32:
.dc.w
0
rotx33:
.dc.w
16384
.bss
150
Abacus Software
ST 3D Graphics
matrixll:
matrixl2:
matrixl3:
matrix21:
matrix22:
matrix23:
matrix31:
matrix32:
matrix33:
* Space here for the general
* rotation matrix
Desk File View Options
253882 butes used 1
K PRINTERS
X TUTORIAL
C FKY
COM TTP
KLIB PRG
OUTPUT PRG
SPLIT TTP
STANDARD PRT
TEXTPRO PRG
TUTORIAL TXT
XTTUTORI TOC
a
I
nmiffiiM 0
1442236 butes used in 128 itens.
BASIC PRG 138944 li-20-Ul
BASIC RSC 4648 11-20 i]
BASIC HRK 346 11-20-
BASIC1 BAR 14801 11-20
OPEN APPLICATION
Name: BATCH .TTP
Parameters: .
aslink grllnkl housel|__-
OK I I Cancel
1
IJI
IkJUl
F:\3DUORK.DIRS
333956 bytes used In
ASLINK1 BAT
BASIC1 S
GRLIHK BAT
BRLINK1 0
6RLINK1 S
6R0UND1 S
HIDE1 PRG
HIDE1 S
HOUSE1 PRG
H0USE1 S
HAIN1 PRG
HAIN1 S
HAIN1C0 PRG
MAIN1C0 S
ST 3D Graphics
Abacus Software
4.1.1 Explanation of the subroutines used
grlinkl.s
The transfer of addresses of all data, coordinates, number of corners and
lines is not made directly, but through global variables. This increases
flexibility and makes it possible to use just one rotation routine. For
example, the perspective transformation routine (pers) transforms the data
whose beginning addresses are passed in the variables pointx,
pointy, pointz and the number of which is passed in the variable
nummark, in an array, whose starting address is also passed
(xplot, yplot). Because of this it does not matter where data is stored
in memory and the amount is irrelevant. For example, the transformation
can be carried out for all defined points or only for a few. The brief
overview which follows on the subroutines of the link file grlinkl. s
should be supplemented with the comments in the program.
s st art: Initialize the program.
aes:
vdi:
Call a function from the AES library.
Calls a function from the VDI library.
ap i n it: Announce an application.
openwork: Open a logical display.
gra f hand: Returns the number of this logical display.
mouse on: Enables the mouse and its controller through the
^ — operating system.
mouse_of f: Switches off mouse and controller.
sincos: Returns the sine (Dl) and cosine value (D2) of an
angle (-360,+360) passed in DO.
st art 1: Asks for the display address of the system and
recognizes what screen resolution is being used;
this serves to determine the two screen pages.
152
Abacus Software
ST 3D Graphics
clwork:
plotpt:
drawl:
rel_pos:
end point:
matinit:
xrotate:
yrotate:
zrotate:
Mtoate:
pers:
VDI-Function, clears the current logical display.
Plots a point, X-coordinate in D2, Y-coordinate in
D3.
Draws a line from XI, Y1 to X2,Y2 taking the
Clip window specified by the variables clipule,
cliplre into account using the line-A routine.
Recognizes the area in which the point passed in
D6 (X-coord.) and D7 (Y-coord.) lies relative to
the clip window. The result is returned in D1 (4-bit
code).
Finds, if present, an intersection point of the line
with the border of the clip window.
Initializes the main diagonal of the rotation matrix
(matrixll-matrix33) with 16384 which
corresponds to a sine value of one.
Multiplies the rotation matrix by the matrix for
one rotation about the X-axis.
Multiplies matrix with the matrix for rotation
about the Y-axis.
Same for Z-axis.
This is the general rotation routine. Here every
point from the point array (passed in point x etc.)
is rotated around the angles xw, yw, zw, and then is
moved to point [xoffs, yoffs, zoffs] after a
preliminary displacement of the coordinate origin
to point [of fx, of fy, of f z],
Calculates the perspective screen coordinates and
stores them at addresses passed in xplot,
yplot.
153
ST 3D Graphics
Abacus Software
symbol:
Connects the points in the screen coordinate array
with lines. The address of the line array is in
linxy, and the number of lines in numlin.
— pagedown:
Turns on the logical screen page. After the call
drawing is done on the other page.
page up:
Turns on the physical (higher) display page.
Subsequent drawing is done on the logical page
(toggle).
waitl:
A timer loop which only counts the DO -register
down to -1.
wait:
Waits for a key press and then returns.
inkey:
Senses the keyboard without waiting. The ASCII
and key codes are returned in register D 0.
printf:
Writes a string on the display which must be
terminated with a zero. The address is passed in
AO.
This routine, and the five following routines are
not used by the first main program. It rotates a
number of points around the Y-axis directly and
without use of matrix multiplication.
The VDI function sets the fill style which is passed
in DO (0=no fill, l=fill with color, 2=fill with dots,
3=shade, 4=user-defined fill pattern).
f i 1 index: Sets the various fill patterns according to style
f ilcolor: Determines the fill color (for monochrome display
only black or white, l=black).
f ilmode: Sets the write mode, 1 = replace.
filform: Subsequent filled surfaces will be surrounded with
a border after calling this routine.
yrot:
5 /
filstyle:
\
154
Abacus Software
ST 3D Graphics
**********************************************************************
* housel.s 14.1.1986 *
* Display a wire-model house Uwe Braun 1985 Version 1.1 *
* *
**********************************************************************
.globl main,xoffs,yoffs,zoffs,offx,offy,offz
.globl viewx,viewy,viewz
.globl wlinxy,setrotdp,inp_chan,pointrot
.text
main:
jsr
apinit
*
Announce program
jsr
grafhand
*
Get screen handler
jsr
openwork
★
Announce screen
jsr
mouse off
*
Turn off mouse
jsr
getreso
*
which monitor is connected ?
jsr
setcocli
*
Set clip window
jsr
makewrld
★
Create the world system
jsr
worldset
*
Pass the world parameters
jsr
setrotdp
★
initialize obs. ref. point
jsr
clwork
★
erase both screen pages
jsr
('•"pagedown^ 5
*
Display logical screen page , j
jsr
clwork
.
Input and change parameters' ^ *
jsr
inp chan
★
mainlopl:
]sr
jsr
jsr
jsr
jsr
jsr
jsr
jsr
jsr
jsr
jsr
* rotate around obs. ref. point
* perspective transformation
* Draw lines in linxy array
inp_chan
clwork
* Display physical screen page
* Input new parameters
* erase V^logical,; screen page
pointrot * Rotate around Rot. ref. point
pers * Transform, of new points
d rawnl _* draw in l ogi cal page, t hen _
pagedowp !) * display this logical page
inp chan- * Input and change parameters
155
ST 3D Graphics
Abacus Software
jsr
clwork *
erase physical page
jmp
mainlopl *
to main loop
move. 1
physbase,logbase
jsr
(pageup) *
switch to normal display page
rts
back to linkfile, and end
********************************************************************
* Remove all accumulated characters in the keyboard buffer "
********************************************************************
clearbuf:
clearend:
move.w
#$b,-(a7)
trap
#1
addq.1
#2,a7
tst. w
dO
beq
clearend
move.w
#1, -(a7)
trap
#1
addq.1
#2,a7
bra
clearbuf
rts
* Gemdos funct. Character in buffer?
* If yes, get character
* If no, terminate
* Gemdos funct.CONIN
* repeat until all characters are
* removed from the buffer
**********************************************************************
* Change observation parameters with keyboard sensing *
* Angle increments, location of the projection plane, etc.
**********************************************************************
inp chan:
jsr
inkey
cmp .b
#' D',dO
bne
inpwait
jsr
scrdmp
inpwait:
swap
dO
cmp .b
#$4d,dO
bne
inpl
addq.w
#1,ywplus
bra
inpendl
inpl:
cmp -b
#$4b,dO
bne
inp2
* Read keyboard, code in DO
* shift D = print
* make hardcopy
* test DO, if
* Cursor-right
* if yes, add one to Y-angle
* increment and continue
* Cursor-left, if yes, then
* subtract one from Y-angle
156
Abacus Software
ST 3D Graphics
subq.w
#1, ywplus
bra
inpendl
inp2:
cmp .b
#$50,dO
bne
inp3
addq. w
#1,xwplus
bra
inpendl
inp3:
cmp. b
#$48,dO
bne
inp3a
subq.w
#1,xwplus
bra
inpendl
inp3a:
cmp .b
#$61,dO
bne
inp3b
subq.w
#1,zwplus
bra
inpendl
inp3b:
cmp.b
#$62,dO
bne
inp4
addq.w
#1,zwplus
bra
inpendl
inp4:
cmp.b
#$4e,dO
bne
inp5
sub. w
#25,dist
bra
inpendl
inp5:
cmp.b
#$4a,dO
bne
inp6
add.w
#25,dist
bra
inpendl
inp6:
cmp.b
#$66,dO
bne
inp7
sub. w
#15,rotdpz
bra
inpendl
inp7:
cmp.b
#$65,dO
bne
inplO
add. w
#15,rotdpz
bra
inpendl
* increment
* Cursor-down, if yes
* then add one to X-angle increment
* Cursor-up
* subtract one
* Undo key
* Help key
* plus key on numerical keypad
* if yes, subtract 25 from location
* Projection plane (Z-coordinate)
\
* minus key on the numerical keypad
*
* if yes, add 25
* astersisk key on numerical keypad
* if yes, subtract 15 from rotation
* point Z-coordinate
* Make changes
* Division key on num.keypad
* add 15
157
ST 3D Graphics
Abacus Software
inplO:
cmp .b
#$44,dO
bne
inpendl
addq. 1
#4,a7
bra
mainend
inpendl:
move. w
hyangle,dl
add. w
ywplus,dl
cmp. w
#360,dl
bge
inpend2
cmp. w
#-360,dl
ble
inpend3
bra
inpend4
inpend2:
sub. w
#360,dl
bra
inpend4
inpend3:
add.w
#360,dl
inpend4:
move.w
dl,hyangle
move . w
hxangle,dl
add.w
xwplus,dl
cmp.w
#360,dl
bge
inpend5
cmp.w
#-360,dl
ble
inpend6
bra
inpend7
inpend5:
sub. w
#360,dl
bra
inpend7
inpend6:
add.w
#360,dl
inpend7:
move.w
dl,hxangle
move. w
hzangle,dl
add.w
zwplus,dl
cmp. w
#360,dl
bge
inpend8
cmp. w
#-360,dl
ble
inpend9
bra
inpendlO
inpend8:
sub. w
#360,dl
bra
inpendlO
inpend9:
add. w
#360,dl
* F10 activated ?
* if yes, jump to
* program end
* Rotation angle about Y-axis
* add increment
* if larger than 360, then
* subtract 360
* is smaller than 360, then
* add 360
* proceed in the same manner
* with the rotation angle about
* the X-axis
* store angle
158
Abacus Software
ST 3D Graphics
inpendlO: move.w dl,hzangle
rts
* Initialize the rotation reference point to [0,0,0] *
move . w
#0, dl
* set the start-rotation-
move . w
dl,rotdpx
* datum-point
move. w
dl,rotdpy
move.w
dl,rotdpz
move . w
#0,hyangle
* Start-rotation angle
move. w
#0,hzangle
move.w
#0,hxangle
rts
* Rotation around one point, the rotation reference point *
pointrot: move.w
hxangle,xangle
move.w
hyangle,yangle
move.w
hzangle,zangle
move . w
rotdpx,dO
move.w
rotdpy,dl
move.w
rotdpz,d2
move. w
dO,xoffs
move.w
dl,yoffs
move.w
d2,zoffs
neg. w
dO
neg. w
dl
neg. w
d2
move.w
dO,offx *
move.w
dl, of fy
move.w
d2,offz
jsr
matinit *
jsr
zrotate *
jsr
yrotate *
jsr
xrotate *
jsr
rotate *
rts
* rotate the world around the angle
* hxangle, hyangle, hzangle about the
* rotation reference point
* add for back transformation.
subtract for transformation.
Matrix initialization
first rotate around Z-axis
rotate 'matrix' around Y-axis
then rotate around X-axis
Multiply points with the matrix.
159
ST 3D Graphics
Abacus Software
* Creation of the world system from the object data *
makewrld:
move.1
thousdatx, al
* create the world system by
move.1
Ihousdaty,a2
move.1
#housdatz,a3
move.1
#worldx,a4
move.1
#worldy,a5
move.1
#worldz,a6
move.w
hnummark,dO
ext .1
dO
subq.1
#1, dO
makewll:
move.w
(al) +, (a4) +
* copying the house data into
move.w
(a2)+, (a5) +
* world data
move. w
(a3)+, (a6) +
dbra
dO,makewll
move . w
hnumline,dO
ext. 1
dO
subq.1
U,dO
move. 1
thouslin,al
move . 1
dwlinxy,a2
makewl2:
move. 1
(al) +, (a2) +
dbra
d0,makewl2
rts
**********************************
* Pass the world parameters to the
**********************************
worldset: move.1
#worldx,datx *
move.1
#worldy,daty *
move.1
#worldz,datz
move.1
#viewx,pointx
move.1
#viewy,pointy
move.1
#viewz,pointz
move.1
#wlinxy,linxy
move.w
picturex,xO
move. w
picturey,yO
move.w
proz,zobs
move.w
rlzl,dist
move.1
#screenx,xplot
**********************************
link file variables *
**********************************
Pass variables for
the rotation routine
160
Abacus Software
ST 3D Graphics
move.1 Iscreeny,yplot
move.w hnumline,numline
move.w hnummark,nummark
rts
*********************************************************************
* sense current display resolution and set coordinate origin of the *
* screen system to the center of the screen *
*********************************************************************
getreso:
move.w
#4,-(a7)
trap
#14
addq.1
#2,a7
cmp.w
#2, dO
bne
getrl
move. w
#320,picturex
* for monochrome monitor
move.w
#200,picturey
bra
getrend
getrl:
cmp.w
#1, dO
bne
getr2
move. w
#320,picturex
* medium resolution (640*200
move.w
#100,picturey
bra
getrend
getr2:
move.w
#160,picturex
* low resolultion (320*200)
move.w
#100,picturey
getrend:
rts
**********************************************************************
* Hardcopy of the display after activating Shift d on keyboard *
**********************************************************************
scrdmp: move.w #20,-(a7)
trap #14
addq.l #2,a7
jsr clearbuf * prevent another hardcopy
rts
161
ST 3D Graphics
Abacus Software
*********************************************************************
* Sets the limit of the display window for the draw-line algorithm *
* built into the Cohen-Sutherland clip algorithm *
* The limits are freely selectable by the user, making the draw- 4
* line algorithm very flexible.
*********************************************************************
move.w
#0, clipxule
*
Clip left X-Coord.
move.w
#0,clipyule
★
” Y-Coord
move. w
picturex,dl
lsl. w
#1, dl
*
times two
subq.w
#1, dl
*
minus one equal
move.w
dl,clipxlri
*
639 for monochrom
move.w
picturey,dl
lsl. w
#1, dl
*
times two minus one equal
subq.w
#1, dl
*
399 for monochrom
move.w
dl,clipylri
★
Clip right Y-Coord
rts
.even
* Here begins the variable area for the program module *
* *
* *
* Definition of the house *
* *
. data
housdatx: .dc.w
,dc. w
-30,30,30,-30,30,-30,-30,30,0,0,-10,-10,10,10
30,30,30,30,30,30,30,30,30,30,30,30
housdaty: .dc.w
.dc.w
.dc.w
30,30,-30,-30,30,30,-30,-30,70,70,-30,0,0,-30
20 , 20 , 0 , 0 , 20 , 20 , 0,0
-10,-10,-30,-30
162
Abacus Software
ST 3D Graphics
housdatz:
.dc.w
.dc.w
.dc.w
houslin:
.dc.w
.dc.w
.dc.w
.dc.w
hnummark:
.dc.w
hnumline:
.dc.w
hxangle:
.dc.w
hyangle:
.dc.w
hzangle:
.dc.w
xwplus:
.dc.w
ywplus:
.dc.w
zwplus:
.dc.w
picturex:
• dc.w
picturey:
.dc.w
rotdpx:
.dc.w
rotdpy:
.dc.w
rotdpz:
.dc.w
rlzl:
.dc.w
normz:
. dc. w
.bss
plusrot:
. ds. 1
first:
.ds. 1
second:
. ds . w
deltal:
.ds. w
.data
60,60,60,60,-60,-60,-60,-60,60,-60,60,60,60,60
40,10,10,40,-10,-40,-40,-10
0 ,- 20 ,- 20,0
1,2,2,3,3, 4,4,1,2,5,5,8,8,3,8,7,7,6,6,5,6,1,7,4
9, 10, 1, 9, 9, 2,5,10, 6,10, 11,12, 12, 13, 13,14
15,16,16,17,17,18,18,15,19,20,20,21,21,22,22,19
23,24,24,25,25,26,26,23
26 * Number of corner points of the house
32 * Number of lines of the house
0 * Rotation angle of the house around X-axis
0 * " " " Y-axis
0 * " " " Z-axis
0 * Angle increment around the X-axis
0 * Angle increment around the Y-axis
0 * Angle increment around the Z-axis
320 * Definition of zero point of display
200 * here it is in the display center
0 * Rotation datum point
0
0
0
1500
1
1
1
1
163
ST 3D Graphics
Abacus Software
flag:
. dc .b
. even
-bss
1
diffz:
.ds.w
1
dx:
.ds .w
1
dy:
-ds.w
1
dz:
.ds.w
1
worldx:
.ds.w
1600
* World coordinate array
worldy:
-ds. w
1600
worldz:
.ds.w
1600
viewx:
.ds.w
1600
* View coordinate array
viewy:
.ds.w
1600
viewz:
.ds.w
1600
screenx:
.ds.w
1600
* Display coordinate array
screeny:
.ds.w
1600
wlinxy:
.ds. 1
3200
* Line array
.data
prox:
.dc. w
0
* Coordinates of the Projection-
proy:
.dc. w
0
* center, on the positive
proz:
. dc. w
1500
* Z-axis
. data
of fx:
.dc. w
0
* Transformation during Rotation
of fy:
. dc. w
0
* to point [offx,offy,offz]
of fz:
. dc. w
0
xoffs:
.dc.w
0
* Back transformation to Point
yoffs:
.dc. w
0
* [xof yof f s, zof fs]
zoffs:
.dc.w
0
7
.bss
loopc:
.ds. 1
1
• end
164
Abacus Software
ST 3D Graphics
4.1.2 Description of the Subroutines of the first Main program:
main: This is the entry point to the program module. The
program announces itself and initializes the AES
and VDI functions and senses the current screen
resolution. The window size and the screen are
determined from the resolution. The program
section between the labels mainopl: and mainend:
is the main loop, which is repeated until the F10
key is pressed.
makewrld: Creates a world in the world coordinate system by
simple copying of the house data into the world
system. These are the coordinates of the house
(housdatx, housdaty, housdatz) in the
world coordinate system (wrldx, wrldy,
wrldz), the lines of the house in houslin in the
world line storage area (wlinxy), the number of
comer points the house (hnummark) in the total-
number variable of the world system (nummark)
and finally the number of house lines (hnumline)
in numline. This subroutine need only be called
once unless you want to add objects to the world
system which we will do in a later program.
wrldset: After creating the world system the array addresses
(wrldx etc.) must be passed to the global
variables of the rotation subroutine (datx etc.).
Furthermore the coordinate origin of the display is
determined in the Variables XO and YO, and the
presets for the perspective parameters
(zobs, dist).
setrotdp: Initializes the rotation reference point to [0,0,0]
and the rotation angles to 0 degrees.
165
ST 3D Graphics
Abacus Software
pointrot:
inp chan:
getreso:
scrdmp:
setcocli:
clearbuf:
This subroutines provides the rotation routine with
the current data and then performs the rotation
around the point [rotdpx, rot dp, rotdpz] of
all three axes with a call to the proper routines of
the link file, in the sequence Z-axis, Y-axis, X-axis.
A change in the sequence also changes the results.
Input and change the parameters, rotation angle,
rotation reference point and position of the projec¬
tion plane.
Checks the current display resolution and from this
determines the data for the screen center and the
clip window, which in this case is the whole visible
display.
Hardcopy routine, is called form inp_chan by
pressing shift ’D’ and replaces the key combination
Altemate/Help, which the operating system uses to
make a hardcopy of the screen. Since in this
program the displayed page is never the same as
the page in which the drawing occurs, a hardcopy
through Altemate/Help would not correspond to
the displayed picture but would print the picture
under construction or the just-erased display. The
trick is to call the scrdmp routine before the
displayed page is erased.
Set the clip-window for the Cohen-Sutherland clip
algorithm on the whole display, 0,0 to 639,399 hi¬
res, 639,199 med-res, or 319,199 lo-res.
Remove characters that may be in the keyboard
buffer. Is used only by the hardcopy routine, since
several hardcopies could otherwise be made in
succession (Key repeat).
166
Abacus Software
ST 3D Graphics
4.1.3 General comments on the program
The specific explanations of the variables can be found in the remarks in
the program listing. In each iteration of the main loop the program adds
an angle increment (xwplus, ywplus, zwplus) to the rotation angle
(hxangle, hyangle, hzangle) of the house. The input routine
changes the angle increments which causes the house to rotate faster on
the screen, though this is really an optical illusion. The end points of the
house have to travel a longer distance between each drawing operation,
which causes this effect. The cursor keys, the <Help> and <Undo> keys
control the rotation, the V and ’-’keys change the display size by
moving the projection plane, and the ’/’ and ’*’ keys move the rotation
reference point on the Z-axis. Pressing of the shift and ’D’ keys at the
same time produces hardcopy if a printer is attached.
The best thing to do is to try out the various changes possible, preferably
by changing the constants in the listing. You can, for example move the
rotation reference point on the X and Y axis, or the variable proz, which
changes the position of the projection center. The closer you move the
projection center in the direction of the house, the greater the perspective
distortion. You should also define an object yourself, and you should start
with a simple object, like a pyramid. You only have to enter the points of
the pyramid (in a pyramid with a quadratic base there are five) in place of
the house coordinates in the arrays (housdatx etc.). Furthermore, the
number of points (5) must be entered in houslin in hnummark, the
number of lines (8) in hnumline and then the information regarding
which points are connected by lines. You only have to change the storage
area and you can represent any defined object with the same program.
Here I want to provide some additional information about the storage
space required. The arrays (wrldx etc., viewx, screenx,
wlinxy) are already dimensioned quite generously for future expansion.
You can define objects with 1600 comers and connect these comers with
3200 lines. About 40 KByte of storage space is needed for this array
dimensioning. Even though 1600 comers appear to be sufficient at first
glance, we shall reach this number in the next chapter without too much
effort. But first of all stop for a while and play around with this program.
You can also add a window on the other side of the house by simply
entering the new coordinates.
167
LIS
projection centers
Abacus Software
ST 3D Graphics
4.2 Generation techniques for creating rotating objects c
\ 1'4,-fc, ?
If you have experimented with the construction of new objects, you
probably also noticed the considerable effort involved in construction,
especially for regularly-formed bodies with many comers. Imagine if you
had to input the end points of the ball approximated by polygons (See
figure 4.2.1).
Figure 4.2.1: Hardcopy of the rotation ball
The drudgery of input can be performed by the computer for all axis-
symmetrical objects. As an example, consider the ’’chess piece’’ from
Figure 4.2.2. This figure can be created by rotating a line (the definition
line) around any axis, in this case the Y-axis. The programmer must
169
ST 3D Graphics
Abacus Software
define the one line and indicate how many times it should be rotated. You
can follow the construction of the figure easily on the following
hardcopies. The rotation number must be a division of 360 for
programming reasons or a portion of the figure will be missing. From two
to four to three hundred sixty rotations are available. More than 180 just
produces a heap of points on the display (the screen resolution is too
low). Now the space requirement will become obvious. If you rotate the
12 points 360 times it results in 4,332 points not to mention the 8,291
lines created by the rotation. The number of points is calculated as
follows: nummark: =numpt* (rotations + 1). The lines include the
connecting lines of the points in the rotating definition line as well as the
horizontal connecting lines of the points in the rotation line.
The routines for the creation of the rotation body are contained in the
listing of the file rotate 1. s. The rotation body is described by a line,
i.e. a number of points (rlnumpt), whose coordinates are in rlxdat,
rlydat, r 1 zdat and the number of rotations about the Y-axis which
this line should perform. The different bodies are created by varying the
number of rotations. The maximum number of rotations in our case is
120, which is predetermined by the dimensioning of the array to 1600 etc.
and of course could be changed. The number of points of the rotation
body is contained in the variable rlnumpt. The link file remains the
same as in the first program. You only have to assemble the first file and
link it to the link file: as link grlinkl rotatel.
Desk File View Options
A:\
253882 butes used i
8 PRINTERS
8 TUTORIAL
C FKY
C0NV TIP
NL1B PRC
OUTPUT PRC
SPLIT TTP
STftNDRRD PRT
TEXTPRO PRC
TUTORIRL TXT
XTTUTORI TOC
D:\
K
1442236 butes used in 123 ltens.
BASIC PR6
BfiSIC RSC
BASIC HRK
BASIC1 BAK
138944 11-28
4648 11-28:
346 11-2
14801 11-2
F:\3DU0RK.DIRS
333556 butes used tn
OPEN APPLICATION
Nanei BATCH
Parameters:
aslink grlinkl rotatei[
• TTP
I OK I ^ | Cancel I
a* a* a* a?
WBSTSE23M I'-H'Ji i"?u■ iinn i : *tw ttnm
H0USE1 PRB
NQUSE1 S
MAIN1 PRG
MAIN1 S
MAIN1C0 PRC
HAIN1C0
HENU1
MENU1
MULTIi
MUL Til
PAINT1
PAINT1
R0TATE1 PRG
R0TATE1 S
S
PRG
S
PRG
S
PRG
S
170
Abacus Software
ST 3D
ST 3D Graphics
Abacus Software
**********************************************************************
* rotatel.s 16.1.1986 *
* Creation of rotation bodies Uwe Braun 1985 Version 2.0 *
.text
.globl main,xoffs,yoffs,zoffs,offx,offy, offz
-globl viewx,viewy,viewz
.globl wlinxy,mouse off,setrotdp,inp chan,pointrot
main:
jsr
apinit
*
jsr
grafhand
*
jsr
openwork
it
jsr
mouse_off
*
jsr
getreso
*
jsr
setcocli
*
jsr
makerotl
jsr
makewrld
*
jsr
wrld2set
*
jsr
setrotdp
*
jsr
clwork
jsr
pagedown
*
jsr
clwork
jsr
inp_chan
*
mainlopl:
jsr
pointrot
*
jsr
pers
*
jsr
drawnl
jsr
pageup
*
jsr
inp_chan
*
jsr
clwork
*
jsr
pointrot
*
jsr
pers
*
jsr
drawnl
jsr
pagedown
*
jsr
inp_chan
*
Announce program
Get screen handle
Display
Turn off mouse
Which monitor is connected ?
Set clip window
Create world system
Pass world parameters
initialize observation ref. point
Display logical screen page
Input and change parameters
rotate around observation ref. point
Perspective transformation
Display physical page
Input new parameters
Erase logical page
Rotate around rotation ref. point
Transform, new points
Display this logical page
Input and change
172
Abacus Software
ST 3D Graphics
mainend:
jsr
clwork *
clear physical page
jmp
mainlopl *
to main loop
move.1
physbase,logba:
se
jsr
pageup *
switch to normal display page
rts
*
back to link file, and end
*
*
*
****************
remove all characters from the keyboard buffer
*******************************************************************
clearbuf: move.w
#$b,-(a7)
trap
#1
addq.1
#2,a7
tst -w
dO
beq
clearend
move.w
#1,- (a7)
trap
#1
addq.1
#2,a7
bra
clearbuf
clearend: rts
* Gemdos funct. char in buffer?
* if yes, get character
* if no, terminate
* Gemdos funct. CONIN
* repeat until all characters
* are removed from the buffer
* Create the rotation body rl
makerotl: jsr
jsr
jsr
rt s
rlset
rotstart
rotlin
* Create the rotation body
* first the coordinates,
* then the lines
173
ST 3D Graphics
Abacus Software
*******************it** + -k1t*-k-k**ic1t1r*1i1iii*1t1r1tl!*1cirit**ir1'1c1r1r***1i1t**i'*iiitit1i1r1rit
* Input and change observation parameters *
* the angles hxangle,hyangle,hzangle, are rotation angles of *
* world system *
inp chan:
jsr
inkey
*
cmp.b
#'D',dO
bne
inpwait
jsr
scrdmp
*
inpwait:
swap
dO
*
cmp.b
#$4d,dO
*
bne
inpl
addq. w
#1,ywplus
*
bra
inpendl
*
inpl:
cmp.b
#$4b,dO
*
bne
inp2
*
subq.w
#1,ywplus
*
bra
inpendl
inp2:
cmp.b
#$50,dO
*
bne
inp3
addq.w
#1,xwplus
*
bra
inpendl
inp3:
cmp.b
#$48,dO
*
bne
inp3a
subq. w
#1,xwplus
*
bra
inpendl
inp3a:
cmp.b
#$61,dO
★
bne
inp3b
subq.w
#1,zwplus
*
bra
inpendl
inp3b:
cmp.b
#$62,dO
*
bne
inp4
addq. w
#1, zwplus
*
bra
inpendl
Sense keyboard, code in
make hardcopy
test DO if
Cursor-right
if yes, add one to Y-angle increment
and continue
Cursor-left, if yes
subtract one from Y-angle
increment
Cursor-down, if yes
add one to X-angle increment
Cursor-up
subtract one
Undo-key
lower Z-increment
Help-key
add to Z-increment
174
Abacus Software
ST 3D Graphics
inp4:
cmp .b
#$4e,dO
* plus key on keypad
bne
inp5
* if yes, subtract 25 from
sub. w
#25,dist
* position of projection
bra
inpendl
* plane (Z-coordinate)
inp5:
cmp.b
#$4a,d0
* minus key on keypad
bne
inp6
*
add.w
#25,dist
* if yes, add 25
bra
inpendl
inp6:
cmp.b
#$66,dO
* times-key on the keypad
bne
inp7
* if yes, then subtract 15
sub. w
#15,rotdpz
* from the rotation ref. point Z-coord.
bra
inpendl
* make changes
inp7:
cmp.b
#$65,dO
* division-key on keypad
bne
inplO
add.w
#15, rotdpz
* add 15
bra
inpendl
inplO:
cmp.b
#$44,dO
* F10 activated ?
bne
inpendl
addq.1
#4,a?
* if yes, jump to
bra
mainend
* Program end
inpendl:
move. w
hyangle,dl
* rotation angle, Y-axis
add.w
ywplus,dl
* add increment
cmp.w
#360,dl
* if larger than 360, then subtract 360
bge
inpend2
cmp. w
#-360,dl
* if smaller than 360,
ble
inpend3
* add 360
bra
inpend4
inpend2:
sub. w
#360,dl
bra
inpend4
inpend3:
add. w
#360,dl
inpend4:
move. w
dl,hyangle
move. w
hxangle,dl
* proceeed in the same
add. w
xwplus,dl
* manner with rotation
cmp.w
#360,dl
* angle, X-axis
bge
inpend5
cmp. w
#-360,dl
175
ST 3D Graphics
Abacus Software
ble
inpend6
bra
inpend7
inpend5:
sub. w
#360,dl
bra
inpend7
inpend6:
add. w
#360,dl
inpend7:
move. w
dl,hxangle
move. w
hzangle,dl
add. w
zwplus,dl
cmp. w
#360,dl
bge
inpend8
cmp. w
#-360,dl
ble
inpend9
bra
inpendlO
inpend8:
sub. w
#360,dl
bra
inpendlO
inpend9:
add.w
#360,dl
inpendlO:
move.w
rts
dl,hzangle
* Initialize the rotation reference point to [0,0,0] *
move.w
#0, dl
* set the start-rotation
move.w
dl,rotdpx
* reference point
move.w
dl,rotdpy
move. w
dl,rotdpz
move. w
#0,hyangle
* Start rotation angle
move.w
#0,hzangle
move. w
#0,hxangle
rts
******************************************************************
* Rotation of the total world system around the rotation *
* reference point *
******************************************************************
pointrot: move.w
move.w
move.w
move.w
hxangle,xangle * rotate the world around
hyangle,yangle
hzangle,zangle
rotdpx,d0 * the rotation reference point
176
Abacus Software
ST 3D Graphics
★
makewrld:
makewll:
jnakewl2 :
move.w
rotdpy,dl
move . w
rotdpz,d2
move. w
dO,xoffs
* add for inverse transformation
move . w
dl,yoffs
move.w
d2,zof fs
neg. w
dO
neg. w
dl
neg. w
d2
move. w
dO,offx
* subtract for transformation
move. w
dl, offy
move. w
d2,offz
jsr
matinit
* matrix initialization
jsr
zrotate
* rotate around Z-axis first
jsr
yrotate
* rotate 'matrix' around Y-axis
jsr
xrotate
* then rotate around X-axis
jsr
rotate
* multiply points with the
rts
* matrix. The Z-axis is not taken into
* account
move. 1
#rldatx,al
* create the world system
move . 1
#rldaty,a2
* by copying data of rotation body
move.1
ffrldatz, a3
* into world system
move.1
#worldx,a4
move. 1
#worldy,a5
move. 1
#worldz,a6
move. w
rlnummark,dO
* number of corners repeated
ext .1
dO
subq. 1
#1, dO
move . w
(al)+, (a4) +
* Copy coordinates
move . w
(a2)+, (a5) +
* Y-coords.
move. w
(a3)+, (a6) +
* Z-coords.
dbra
dO,makewll
move.w
rlnumline,dO
* Copy the line arrays
ext. 1
dO
* of the rotation body
subq.1
#1, dO
* into the world system
move.1
#rllin,al
* Number of lines as counter
move.1
#wlinxy,a2
move.1
(al)+,(a2)+
* copy lines
dbra
dO,makew!2
rt s
177
ST 3D Graphics
Abacus Software
***********************************************************************
* Pass world parameters to variables of link files *
***********************************************************************
worldset: move.l
#worldx,datx
move.1
fworldy,daty
move.1
#worldz,datz
move.1
#viewx,pointx
move.1
#viewy,pointy
move.1
#viewz,pointz
move.1
#wlinxy,linxy
move.w
picturex,xO
move.w
picturey,yO
move.w
proz,temp
move.w
rlzl,dist
move.1
iscreenx,xplot
move.1
iscreeny,yplot
move.w
hnumline,numline
move.w
hnummark,nummark
rts
* Passing house variables
* for the rotation routine
* and the global subroutine
* of the link module
* Projection center Z-coordinate
* Location of projection plane on
* the Z-axis
* Number of house lines
* Number of house corners
***********************************************************************
* Creation of rotation body in the array, the address of which *
* is passed in the variables rotdatx, rotdaty, rotdatz *
***********************************************************************
rlset:
move. 1
#rlxdat,rotxdat
★
Transmit
move. 1
#rlydat,rotydat
*
parameters of this
move.1
#rlzdat,rotzdat
★
rotation body to
move.1
irldatx,rotdatx
★
the routine for
move.1
ffrldaty, rotdaty
*
creation of the
move.1
#rldatz,rotdatz
*
rotation body
move.1
rotdatx,datx
move. 1
rotdaty,daty
move. 1
rotdatz,datz
move. w
rlnumro,numro
*
Number of desired
move.w
rlnumpt,numpt
*
rotations. Number
move.l
#rllin,linxy
*
of points in def.line
rts
★
Address of line array
178
Abacus Software
ST 3D Graphics
rotstart:
rloopl:
move.w
numpt,dO
lsl. w
#1, dO
ext. 1
dO
move.1
dO,plusrot
move.w
numpt,nummark
move. 1
rotdatx,pointx
move.1
rotdaty,pointy
move.1
rotdatz,pointz
move.w
#0,yangle
move.w
#360,dO
divs
numro,dO
move.w
dO, plusagle
move. w
numro,dO
ext. 1
dO
move.1
dO,loopc
move.1
rotxdat,datx
move.1
rotydat,daty
move.1
rotzdat,datz
jsr
yrot
move. 1
pointx,dl
add. 1
plusrot,dl
move. 1
dl,pointx
move. 1
pointy,dl
add. 1
plusrot,dl
move. 1
dl,pointy
move. 1
pointz,dl
add. 1
plusrot,dl
move. 1
dl,pointz
move.w
yangle,d7
add. w
plusagle,d7
move. w
d7,yangle
move. 1
loopc,dO
dbra
dO,rloopl
move. w
rlnumro,numro
move.w
rlnumpt,numpt
rts
* Rotate def line
* numro+1 about Y-axis
* Pass data array
* to subroutine yrot
* 360 / numro = angle increment
* per rotation
* numro +1 times
* as loop counter
* for passing to yrot
* rotate
* add offset to
* address
* Add angle increment
* to rotation angle
* and rotate line
* again until all
* end points are generated.
* store for following
* routines for line generation
179
ST 3D Graphics
Abacus Software
rotlin:
rotlopl:
rotlop2:
rotlop3 :
* Create the line array of the
move.w
#1, d7
* rotation body
move.w
numro,d4
* Number of rotations repeated
ext. 1
d4
subq. 1
#1, d4
move.w
numpt,dl
subq.w
*1, dl
lsl. w
#2, dl
ext. 1
dl
move.1
dl,plusrot
move.w
numpt,d5
* Number of points -
ext. 1
d5
* repeat once
subq.1
#2,d5
move.1
linxy,al
* Lines created stored
move.w
d7,d6
* here
move.w
d6, (al) +
* The first line goes from
addq.w
#1, dG
* point one to point two
move.w
d6, (al) +
* (1,2) then (2,3) etc.
dbra
d5,rotlop2
move. 1
linxy,dl
* generate cross connections
add. 1
plusrot,dl
* of individual lines
move.1
dl,linxy
move.w
numpt,dO
add.w
d0,d7
dbra
d4,rotlopl
move. w
numpt,d7
move.w
d7,deltal
lsl. w
#2,d7
ext. 1
dl
move.1
d7,plusrot
move.w
#l,d6
move. w
numpt,dO
ext. 1
dO
subq.1
#1, dO
move.w
numro,dl
ext. 1
dl
subq.1
#1, dl
move.w
d6,d5
180
Abacus Software
ST 3D Graphics
move.w
d5, (al) +
add. w
deltal,d5
move.w
d5,(al)+
dbra
dl,rotlop4
add. w
#l,d6
dbra
dO,rotlop3
move. w
numro,dl
add. w
#1, dl
mul s
nummark,dl
move.w
dl,rlnummark
move.w
numpt,dl
muls
numro,dl
move . w
numpt,d2
subq.w
#1, d2
muls
numro,d2
add. w
dl, d2
move.w
rts
d2,rlnumline
* Store total number of
* corners created
* Total of lines created
* Pass parameters of the world system to variables *
* of the link file for the rotation body *
wrld2set: move.1
iworldx,datx
*
Pass parameter
of
move.1
fworldy,daty
*
rotation body '
to the
move.1
#worldz,datz
*
subroutines in
the link
move.1
#viewx,pointx
*
module
move.1
#viewy,pointy
move.1
#viewz,pointz
move.1
#wlinxy,1inxy
move.w
picturex,xO
move.w
picturey,yO
move. w
proz,temp
move.w
rlzl,dist
move.1
Iscreenx,xplot
move.1
#screeny,yplot
181
ST 3D Graphics
Abacus Software
move.w rlnumline,numline * Number of lines
move.w rlnummark,nummark * Number of corners
rts
a**********************************************************************
* Sense current display resolution and set the coordinate *
* origin of the screen system to the screen center *
***********************************************************************
getreso:
move. w
#4,-(a7)
trap
#14
addq. 1
#2,a7
cmp. w
#2, dO
bne
getrl
move.w
#320,picturex
* monochrome monitor
move. w
#200,picturey
bra
getrend
getrl:
cmp. w
#1, dO
bne
getr2
move. w
#320,picturex
* medium resolution (640*200
move.w
#100,picturey
bra
getrend
getr2:
move.w
#160,picturex
* low resolution (320*200)
move.w
#100,picturey
getrend:
rts
* Hardcopy after inp_chan call *
scrdmp:
move. w
trap
addq. 1
jsr
rts
#20,-(a7)
#14
#2, a7
clearbuf
182
Abacus Software
ST 3D Graphics
*********************************************************************
* Set the limit of the window for the Cohen-Sutherland *
* clip algorithm built into the draw-line algorithm *
* The user can choose the limits freely, which makes the *
* draw-line algorithm very flexible. *
*********************************************************************
move.w
#0,clipxule
move.w
#0, clipyule
move.w
picturex,dl
lsl .w
#1, dl
★
times two
subq.w
#1, dl
A
minus one equals
move.w
dl,clipxlri
*
639 for monochrom
move.w
picturey,dl
lsl .w
#1, dl
★
times two minus one
subq.w
#1, dl
★
equals 399 for monochrom
move.w
dl,clipylri
rts
. even
* Begin variable area for Program module *
* *
* Data area for the rotation body *
.bss * Space for the variables
numro: .ds.w 1
numpt: .ds.w 1
worldfla: .ds.l 1
rotxdat: .ds.l 1
rotydat: .ds.l 1
rotzdat: .ds.l 1
ST 3D Graphics
Abacus Software
rotdatx:
.ds. 1
1
rotdaty:
.ds. 1
1
rotdatz:
. ds. 1
1
rlnumline:
.ds .w
1
rlnummark:
.ds. w
1
rlnumfla:
. ds. w
1
plusagle:
. ds. w
1
rldatx:
.ds. w
1540
rldaty:
. ds. w
1540
rldatz:
.ds. w
1540
rllin:
.ds. 1
3200
.data
* for every line 4-Bytes
***********************************************************************
* These are the coordinates of the definition line which *
* generates the rotation body through rotation about *
* the Y-axis. By changing coordinates the body to be *
* created can be changed. Of course, the number of points in *
* rlnum pt must be adapted to the new situation. By changing *
* rlnumro the current body can be changed as well. *
* Storage reserved here is enough for a maximum 120 rotations *
* of 12 points. This means that for a user-defined *
* rotation line, the product of the number of points and *
* number of desired rotations plus one, cannot be greater *
* than 1500. *
***********************************************************************
rlxdat: .dc.w 0,40,50,50,20,30,20,30,70,80,80,0
rlydat: -dc.w 100,100,80,60,40,30,30,-70,-80,-90,-100,-100
rlzdat: .dc.w 0,0,0,0,0,0,0,0,0,0,0,0
rlnumpt: .dc.w
rlnumro: .dc.w
12
8 * Number of rotations for creation
184
Abacus Software
ST 3D Graphics
* Definition of the house *
* *
.data
housdatx: .dc.w
.dc.w
housdaty: .dc.w
.dc.w
.dc.w
housdatz: .dc.w
.dc.w
.dc.w
houslin: .dc.w
.dc.w
.dc.w
.dc.w
hnummark:
.dc.w
hnumline:
.dc.w
hxangle:
.dc.w
hyangle:
.dc.w
hzangle:
.dc.w
xwplus:
.dc.w
ywplus:
.dc.w
zwplus:
.dc.w
picturex:
.dc
picturey:
. dc
-30,30,30,-30,30,-30,-30,30,0,0,-10,-10,10,10
30,30,30,30,30,30,30,30,30,30,30,30
30,30,-30,-30,30,30,-30,-30,70,70,-30,0,0,-30
20 , 20 , 0 , 0 , 20 , 20 , 0,0
-10,-10,-30,-30
60,60,60,60,-60,-60,-60,-60,60,-60,60,60,60,60
40,10,10,40,-10,-40,-40,-10
0 ,- 20 ,- 20,0
1,2,2, 3,3, 4,4,1,2,5,5,8, 8,3, 8, 7,7,6, 6,5,6,1,7, 4
9,10,1,9,9,2,5,10,6,10,11,12,12,13,13,14
15,16,16,17,17,18,18,15,19,20,20,21,21,22,22,19
23,24,24,25,25,26,26,23
26 * Number of corners in the house
32 * Number of lines in the house
0 * Rotation angle of house about X-axis
0 * .in « Y-axis
0 * " " " Z-axis
0 * Angle increment around X-axis
0 * Angle increment around Y-axis
0 * Angle increment around Z-axis
0 * Definition of zero point of the screen
0 * provided with values from subroutine getreso
185
ST 3D Graphics
Abacus Software
rotdpx:
• dc.w
0
rotdpy:
.dc.w
0
rotdpz:
.dc.w
0
rlzl: .dc.w 0
normz: .dc.w 1500
.bss
plusrot:
.ds. 1
1
first:
. ds. w
1
second:
.ds. w
1
deltal:
.ds . w
1
.data
flag:
.dc.b
1
.even
.bss
diffz:
.ds. w
1
dx:
.ds .w
1
dy:
.ds. w
1
dz :
.ds. w
1
worldx:
. ds. w
1600
* World coordinate array
worldy:
.ds. w
1600
worldz:
. ds. w
1600
viewx:
.ds. w
1600
* View coordinate array
viewy:
.ds. w
1600
viewz:
.ds. w
1600
screenx:
,ds. w
1600
* Screen coordinate array
screeny:
. ds. w
1600
186
Abacus Software
ST 3D Graphics
wlinxy:
.ds. 1
3200
*
Line array
• data
prox:
. dc. w
0
*
Coordinates for projection-
proy:
. dc. w
0
*
center here on the positive
proz:
.dc. w
1500
*
Z-axis
.data
of fx:
.dc.w
0
★
Transformation for rotation
of fy:
. dc. w
0
*
to point [offx,offy,offz]
of f z :
.dc.w
0
xoffs:
.dc.w
0
*
Inverse transformation for point
yoffs:
.dc.w
0
★
[xoff,yoffs, zoffs]
zoffs:
.dc.w
0
.bss
loopc:
.ds. 1
.end
1
187
ST 3D Graphics
Abacus Software
4.2.1 New subroutines in this program:
r 1 set: Supplies the rotation body creation routine with the
parameters of the specific rotation body, i.e. with
the address of its definition line, with the number
of the points forming this line and the desired
number of rotations.
makerotl: Creates the rotation body rotl in the array
rldatx, rldaty, rldatz, and the lines
(rllin) and passes the total number of points and
lines created.
rotstart: Creates the points of the rotation body and is called
by makerotl as is:
rot 1 in: Creates the lines of the rotation body.
wrld2set: Passes the parameters of the world system and the
rotation body to the link file variables. The
variables for storing of the rotation angle
hxangle remain the same, nothing in inp_chan
needs to be changed.
In contrast to the first program where the house was already explicitly
provided, the object to be represented must first be created. This is the
task of the subroutine makerotl, which generates the rotation body in
the array rldatx, rldaty, rldatz. This array corresponds to the
house array housdatx, housdaty, housdatz. The rotation body is
transferred to the world system and its position parameters in the main
loop are modified in a loop. You should experiment freely with this
program and change the definition line for the rotation body and the
number of rotations. The only limitation is in the maximum number of
points and lines where the total number of lines rlnumline is calculated
as follows:
rlnummark: Total number of comers in the rotation body
rlnumline: Total number of lines in the rotation body
r lnumpt : Number of points in the definition line
188
Abacus Software
ST 3D Graphics
r lnumro: Number of desired rotations of the definition line
rlnumline:= ((rlnumpt - 1) * (rlnumro) +
(rlnumpt * rlnumro))
rlnummark:= (rlnumpt * (rlnumro + 1))
The number of points can not exceed 1600 and the number of lines
cannot be greater than 3200.
The expression (rlnumro+1) results from the programming trick, of
rotating the definition line one time more than necessary. The definition
line, which is the first line in the array, is created a second time at the end
of the array. This simplifies the construction of the line array. And now
you can try the various rotation lines such as the following:
Definition of a Ball:
* Definition line and parameter of the ball *
* from Fig. 4.2.1 ************
rlxdat: .dc.w
rlydat: .dc.w
rlzdat: .dc.w
rlnumpt: .dc.w
rlnumro: .dc.w
for creation
0,40,70,90,100,90,70,40,0
100,90,70,40,0,-40,-70,-90,-100
0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,0
9
60 * Number of rotations
You need only exchange the corresponding lines in the listing for these.
The operation parameters of the program are the same as in house 1:
cursor left and right:
Change the Y-rotation angle increment
cursor up and down:
Change the X-rotation angle increment
undo and help:
Change the Z-rotation angle increment
189
ST 3D Graphics
Abacus Software
+ and - on the keypad:
Move the projection plane on the Z-axis (increase or decrease the size of
object).
* and / on the keypad:
Move the rotation reference point on the Z-axis
Shift 'D':
Hardcopy on the printer
190
Abacus Software
ST 3D Graphics
4.3 Hidden line algorithm for convex bodies
If you are familiar with real time 3-D graphics on other computers, you
were probably surprised by the speed of the display of the wire frame
drawings on the Atari ST. On the other hand some game freaks may
remark that "I’ve seen the fastest 3-D games on my 8-bit C-64 and these
wire models just don’t compare.” For game programming, the main
emphasis is on the desired effect. Therefore the active figures for these 3-
D-Games are mostly space ships and landscapes which are pre-calculated
and their point coordinates are already stored in the computer. For the
display which follows on the screen, the object is simply drawn, which
naturally can be done quickly, even with 8-bit computers. A disadvantage
of this method is the enormous storage requirement, since every possible
position of the object must be available in memory, meaning that this
procedure cannot be used with complex bodies. In this case only the
rotation matrices for the rotation around three axes are calculated ahead
of time and stored in a table. Even with this method the limits of the
storage are reached quickly. An extreme example: If you want to
calculate the rotation matrices of all possible values for subsequent
rotation about three axes, with an angle increment of one degree
previously calculated, the result will be more than 46 million possibilities
(variations of three rotations around 360 possible angles). If this method
is used, the degree of freedom of the objects must be limited to one or
two possible axes, and/or the gradations of the angle values must be
raised so that the table is calculated, for example, only in ten degree
steps, or only rotations from zero to to ninety degrees are permitted.
Another common method consists of defining the objects as picture
shapes, quasi-sprites, in various positions and to switch back and forth
between the various shapes and to move the whole shape over the
display. Of course the last procedure is the fastest since nothing has to be
calculated and the only operation is moving data into the screen memory.
Now back to the Atari ST, which, because of its enormous computing
power, can not only calculate the wire frame drawing in real time, but as
you will see also offers the ability to display simple convex bodies in real
time without the hidden lines. The method used corresponds to the
surface method used in chapter 2.7. To use this method you must specify
every surface of the object precisely. For the example of our house, we
need two new variables. First the number of surfaces of the house
(hnumpla=13), and second the storage space for the description of
these surfaces (houspla). Every surface is described by the number of
191
ST 3D Graphics
Abacus Software
lines pertaining to it, followed by the lines themselves. The description:
4,1,2,2,3,3,4,4,1 would mean:
Four lines belong to this surface and appear as follows:
Line #. connects Point # with Point #
1 1 2
2 2 3
3 3 4
4 4 1
To return to the example of our house, it will be necessary to describe all
of the surfaces of this house in the same manner. For this reason we draw
the various views of the house and number the surfaces in any desired
sequence as in Figures 4.3.1 to 4.3.6. In these illustrations the desired
result is already achieved, i.e. the hidden lines are already removed to
prevent confusion.
Figure 4.3.1 - 4.3.6: Hardcopy of House Views
192
Abacus Software
ST 3D Graphics
ST 3D Graphics
Abacus Software
point. To make it possible for the algorithm to recognize the hidden
surfaces, the sequence of the line points (the direction of the individual
lines) is not arbitrary but must be done in the clockwise direction. This is
the procedure:
1. Number the surfaces.
2. Create a surface array containing the number of lines
(counted clockwise) of each surface as well as the lines of
each surface, as viewed from the outside.
3. When all surfaces have been taken care of the number of
surfaces are stored in a variable (numpla).
Here is the surface list for the thirteen surfaces of the house from Figure
4.3.1. You can get the point indices from Figure 4.1.3.
Surface # Number Lines Lines from Point #
to Point #
1
4
1, 2
2, 3
3/ 4
4, 1
2
4
2, 5
5, 8
8, 3
3, 2
3
4
5, 6
6, 7
7, 8
8, 5
4
4
7, 6
6, 1
1/ 4
4, 7
5
4
4, 3
3, 8
8, 7
7, 4
6
4
2, 9
9, 10
10, 5
5, 2
7
4
10, 9
9, 1
1, 6
6,10
8
3
1/ 9
9, 2
2, 1
9
3
5, 10
10, 6
6, 5
10
4
11, 12
12,13
13, 14
14,11
11
4
15,16
16, 17
17,18
18,15
12
4
9,20
20,21
21,22
22,19
13
4
23,24
24,25
25,26
26,23
Number of surfaces: 13
With this method of surface definition you can describe up to 32,000
lines which can be the connecting lines for 16,000 different points,
though only if you have enough memory, of course. The actual main
program hidel. s corresponds to the first main program house 1. s.
Two subroutines have been added: hideit: and surfdraw: and two
196
Abacus Software
ST 3D Graphics
other changes were made in the main loop. The subroutine hide it
determines which surfaces are visible from the projection center with the
help of the information in the surface arrary (wplane). The information
on the visible surfaces, which correspond to the normal surfaces in the
structure, first the number of lines followed by individual lines, is entered
into a second array (vplane) and the total number of visible surfaces is
stored in the surface counter surfcnt. All visible surfaces are
subsequently drawn on the display by the subroutine surf dr aw:
whereby many lines are drawn twice since the subroutine surf dr aw:
takes the lines to be drawn directly from the surface array (vplane).
Figure 4.3.1 and the connecting lines of points 2 and 3 show a concrete
illustration. This connecting line belongs to the visible surface 1 and the
visible surface 2. Naturally all the lines in the surface array (vplane)
could be sorted before drawing and double lines removed. My experience
shows that the time saved in drawing is lost in the additional sorting and
testing, at least for less complicated bodies. Furthermore, the surface
information is lost by the separation of the lines, which is needed in the
following program sections. Again to run this program you must first
compile and link it to grlinkl.s using the batch.ttp file and
entering: aslink grlinkl hidel
Desk File View Options
»' - . I" "
0 :\ 4
BASIC1C0 S
S BATCH
TTP
BUS
i iifl
bib
Inlli
BAT
COLOR
BAK
COLOR
PRG
COLOR
S
COLOR1
BAK
COLOR1
0
COLOR1
S
m
w-1
r-
im
□
-is
□
E: \
F:\3DW0RK.DIRS !
B butes used
X ASStLPRO
HIDEl S
X FILE-PRO
H0USE1 PRG
X FORTOT
H0USE1 S
X GEHDRAM
MAIH1 PRG
— laTMt ?
OPEN APPLICATION
Kane: BATCH
Parameters: .
aslink grlinkl hldelj-
• TTP
Cancel I
rIKICO pro
PIN1C0 S
HU1 PRO
NU1
ILTI1
mil
IINT1
IINT1
S
PRO
S
PRG
S
R0TRTE1 PRG
ROTATEl S
W a* a" a*.
was Ol n -■! '."il'M ;irna nw rrtm
flCCBESXMi
197
ST 3D Graphics
Abacus Software
* hidel.s 19.1.86 Version 3.0 *
* House with hidden-line algorithm *
* *
.globl
main,xoffs,yoffs,zoffs,offx,offy,offz
-globl
viewx,viewy,viewz
.globl
wlinxy,mouse off,setrotdp,inp chan,pointrot
.text
main:
jsr
apinit
* Announce program
jsr
grafhand
* Get screen handler
jsr
openwork
* Display
jsr
mouse off
* Turn off mouse
jsr
getreso
* what resolution ?
jsr
setcocli
* Prepare clip window
move.1
#houspla.
worldpla * Address of surface array
jsr
makewrld
* Create world system
jsr
wrldset
* Pass world parameters
jsr
setrotdp
* initialize observer ref. point
jsr
clwork
jsr
pagedown
* Display logical page
jsr
clwork
jsr
inp_chan
* Input and change parameters
mainlopl:
jsr
pointrot
*
rotate about observer ref. point
jsr
pers
*
Perspective transformation
jsr
hideit
jsr
surfdraw
jsr
pageup
*
Display physical page
jsr
inp chan
*
Input new parameters
jsr
clwork
jsr
pointrot
*
Rotate around rotation ref. point
jsr
pers
*
Transform new points
jsr
hideit
jsr
surfdraw
198
Abacus Software
ST 3D Graphics
jsr
jsr
jsr
jmp
pagedown
inp_chan
clwork
mainlopl
* Display this logical page
* Input and change parameters
* erase physical page
* to main loop
mainend: move.1 physbase,logbase
jsr
rt s
pageup
* switch to normal display page
* back to link file, and end
* Input and change parameters such as angle increments and
* Z-coordinate of the projection plane
inp_chan:
jsr
inkey
cmp.b
#'D',dO
bne
inpwait
jsr
scrdmp
inpwait:
swap
dO
cmp.b
#$4d,dO
bne
inpl
addq. w
#1,ywplus
bra
inpendl
inpl:
cmp.b
#$4b,dO
bne
inp2
subq.w
#1,ywplus
bra
inpendl
inp2:
cmp.b
#$50,dO
bne
inp3
addq.w
#1,xwplus
bra
inpendl
inp3:
cmp.b
#$48,dO
bne
inp3a
subq.w
#1,xwplus
bra
inpendl
* Sense keyboard, keyboard code in
* Make harcopy
* Test DO for
* Cursor-right
* if yes, then add one to
* Y-angle increment and continue
* Cursor-left, if yes
* then subtract one from
* Y-angle increment
* Cursor-down, if yes
* then add one to X-angle increment
* Cursor-up
* subtract one
199
ST 3D Graphics
Abacus Software
inp3a:
cmp.b
#$61,dO
bne
inp3b
subq * w
#1,zwplus
bra
inpendl
inp3b:
cmp.b
#$62,dO
bne
inp4
addq.w
#1,zwplus
bra
inpendl
inp4:
cmp.b
#$4e,dO
bne
inp5
sub. w
#25,dist
bra
inpendl
inp5:
cmp.b
#$4a,dO
bne
inp6
add.w
#25,dist
bra
inpendl
inp6:
cmp.b
#$66,dO
bne
inp7
sub. w
#15,rotdpz
bra
inpendl
inp7 :
cmp.b
#$65,dO
bne
inplO
add.w
#15,rotdpz
bra
inpendl
inplO:
cmp.b
#$44,dO
bne
inpendl
addq.1
#4,a7
bra
mainend
inpendl:
move.w
hyangle,dl
add. w
ywplus,dl
cmp. w
#360,dl
bge
inpend2
cmp. w
#-360,dl
ble
inpend3
bra
inpend4
* Undo key
* Help key
* + key on keypad
* if yes then subtract 25 from
* location of projection plane
* (Z-coordinate)
* - key on keypad
*
* if yes then add 25
* * key on keypad
* if yes, subtract 15 from the
* rotation point Z-coordinate
* Make change
* / key of keypad
* Add 15
* F10 pressed ?
* if yes, jump to
* program end
* Rotation angle about Y-axis
* add increment
* if larger than 360, subtract 360
* if smaller than 360
* add 360
200
Abacus Software
ST 3D Graphics
inpend2:
sub. w
#360,dl
bra
inpend4
inpend3:
add.w
#360,dl
inpend4:
move.w
dl,hyangle
move.w
hxangle,dl
add.w
xwplus,dl
cmp. w
#360,dl
bge
inpend5
cmp. w
#-360,dl
ble
inpend6
bra
inpend7
inpend5:
sub. w
#360,dl
bra
inpend7
inpend6:
add.w
#360,dl
inpend?:
move.w
dl,hxangle
move.w
hzangle,dl
add.w
zwplus,dl
cmp. w
#360,dl
bge
inpend8
cmp. w
#-360,dl
ble
inpend9
bra
inpendlO
inpend8:
sub.w
#360,dl
bra
inpendlO
inpend9:
add.w
#360,dl
inpendlO
: move.w
dl,hzangle
rts
* Treat
* rotation angle about X-axis
* in the same manner
* Initialize the rotation reference point to [0,0,0] and the
* rotation angle also to 0,0,0
************************************************** ********************
setrotdp: move.w
move. w
move.w
move.w
#0, dl
dl,rotdpx
dl,rotdpy
dl,rotdpz
* set the start rotation-
* datum point
201
ST 3D Graphics
Abacus Software
move.w #0,hyangle * Start rotation angle
move.w #0,hzangle
move.w #0,hxangle
rts
************************************************************************
* Rotate the total world system around one point, the rotation *
* reference point *
************************************************************************
pointrot: move.w
hxangle,xangle * rotate the world around the
move.w
hyangle,yangle
move.w
hzangle,zangle
move.w
rotdpx,dO
* rotation reference point
move.w
rotdpy,dl
move.w
rotdpz,d2
move.w
dO,xoffs
* add for inverse transformation
move.w
dl,yoffs
move. w
d2,zoffs
neg. w
dO
neg. w
dl
neg. w
d2
move.w
dO,offx
* subtract for transformation
move.w
dl,offy
move.w
d2,offz
jsr
matinit
* Matrix initialization
jsr
zrotate
* first rotate about Z-axis
jsr
yrotate
* rotate 'matrix' about Y-axis
jsr
xrotate
* then about X-axis
jsr
rotate
* Multiply points with matrix
rts
***********************************************************************
* Generate world system from object data. All points, lines, *
* and surfaces are transferred to the world system *
***********************************************************************
makewrld: move.1
move. 1
move.1
move.1
move.1
#housdatx,al
ihousdaty,a2
#housdatz,a3
twrldx ,&A
#wrldy,a5
* Generate world system by
202
Abacus Software
ST 3D Graphics
move.l #wrldz,a6
move.w hnummark,dO
ext.l dO
subq.l #l,dO
makewll: move.w (al)+, (a4) +
move.w (a2)+, (a5)+
move.w {a3)+,(a6) +
dbra dO,makewll
move.w hnumline,dO
ext.l dO
subq.1 #1/dO
move.l #houslin,al
move.l #wlinxy,a2
makewl2: move.l (al)+,(a2)+
dbra d0,makewl2
move.l worldpla,aO
move.l #wplane,al
move.w hnumsurf,dO
ext.l dO
subq.l #l,dO
makewl3: move.w (aO)+,dl
move.w dl,(al)+
ext.l dl
subq.l #l,dl
makewl4: move.l (a0)+, (al) +
dbra dl,makewl4
dbra d0,makewl3
rts
* Copying point coordinates
* to world system
* Number of house lines
* Copy all lines into
* world system
* Number of surfaces on house
* Copy all surface
* definitions into the
* world system
* Copy every line of this
* surface into the world array
* until all surfaces are processed
* Passing the world parameters to the link file variables
wrldset: move.l #wrldx,datx * Pass variables for
move.l #wrldy,daty * the rotation routine
move.l #wrldz,datz
move.l ^viewx,pointx
203
ST 3D Graphics
Abacus Software
move.1
#viewy,pointy
move.1
#viewz,pointz
move.1
#wlinxy,linxy
move.w
picturex,xO
move.w
picturey,yO
move.w
proz,zobs
move.w
rlz1,dist
move.1
tscreenx,xplot
move.1
tscreeny,yplot
move. w
hnumline,numline
move.w
hnummark,nummark
move.w
rts
hnumsurf,numsurf
* remove all characters from the keyboard buffer *
clearbuf:
clearnd:
move.w
#$b,-(a7)
trap
#1
addq.1
#2, a?
tst. w
dO
beq
clearnd
move. w
#1,-(a7)
trap
#1
addq.1
#2, a7
bra
clearbuf
rts
*********************************************************************
* Sense display resolution and set coordinate origin of screen *
* to screen center *
*********************************************************************
move.w
#4,-<a7)
* Sense screen resolution
trap
#14
addq.1
#2,a7
cmp. w
#2, dO
bne
getrl
move.w
#320,picturex
* Monochrome monitor
204
Abacus Software
ST 3D Graphics
move.w #200,picturey
bra getrend
getrl: cmp.w #l,d0
bne getr2
move.w #320,picturex * medium resolution (640*200)
move.w #100,picturey
bra getrend
getr2: move.w #160,picturex * low resolution (320*200)
move.w #100,picturey
getrend: rts
***********************************************************************
* Hardcopy routine, called by inp_chan
***********************************************************************
scrdmp: move.w
trap
addq.1
jsr
rts
#20,-(a7)
#14
#2.a7
clearbuf
*********************************************************************
* Sets the limits of the display window for the Cohen-Sutherland
* clip algorithm built into the draw-line algorithm.
* The limits can be freely selected by the user, which makes the
* draw-line algorithm very flexible.
****************
move . w
#0,clipxule
move.w
#0,clipyule
move.w
picturex,dl
lsl. w
#l,dl
*
times two
subq.w
#l,dl
*
minus one equal
move.w
dl,clipxlri
*
639 for monochrome
move.w
picturey,dl
lsl. w
#1, dl
*
times two minus one equal
subq.w
#1, dl
*
399 for monochrome
move.w
dl,clipylri
rts
205
ST 3D Graphics
Abacus Software
***********************************************************************
* Recognition of hidden surfaces and entry of these into the *
* vplane array, the surface information is in the surface array *
* wplane, as well as in view system, viewx, viewy, viewz, *
* also the total number of surfaces must be passed in numsurf *
***********************************************************************
hideit:
visible:
move.w
numsurf,dO
i
' Number of surfaces as counter
ext .1
dO
subq.1
#1, dO
move.1
#viewx,al
*
Store point coordinates here
move.1
#viewy,a2
move.1
#viewz,a3
move.1
Iwplane,aO
*
Information for every surface
move.1
#vplane,a5
*
here.
move.w
#0, surfcount
* counts the known visible surfaces.
move.w
(aO),dl
*
start with first surface, number
ext. 1
dl
*
of points of this surface in Dl.
move.w
2(aO),d2
*
Offset of first point of this surf.
move.w
4(aO),d3
*
Offset of second point
move.w
8(aO),d4
*
Offset of third point
subq.w
#1, d2
*
for access to point arrays subtract
subq.w
#1, d3
*
one from current point offset
subq.w
#1, d4
*
multiply by two
lsl. w
#l,d2
lsl. w
#1, d3
lsl. w
#l,d4
*
and finally access current point
move.w
(al,d3.w),d6
*
coordinates
cmp. w
(al, d4 . w) , d6
*
comparison recognizes two points
bne
doitl
*
with same coordinates which can
move.w
(a2,d3.w),d6
*
result during construction of
cmp. w
(a2,d4.w),d6
*
rotation bodies. During recognition
bne
doitl
*
of two points in which all point
move.w
<a3,d4.w),d6
*
coordinates match (x,y,z) the
cmp.w
(a3, d3 . w) , d6
*
program selects a third point for
bne
doitl
*
determination of the two vectors
move.w
12(aO),d4
subq.w
#l,d4
lsl. w
#1, d4
206
Abacus Software
ST 3D Graphics
doit1:
move.w
(al,d3.w),d5
move.w
d5, kx
sub. w
(al,d2.w),d5
move.w
d5,px
move.w
(a2,d3.w),d5
move.w
d5,ky
sub. w
(a2,d2.w),d5
move.w
d5,py
move.w
(a3, d3 . w) , d5
move.w
d5, kz
sub. w
(a3,d2.w), d5
move.w
d5, pz
move.w
(al, d4.w),d5
sub. w
(al, d2.w),d5
move.w
(a2, d4.w),d6
sub. w
(a2,d2.w) ,d6
move.w
(a3,d4.w),d7
sub.w
(a3,d2.w),d7
move.w
d5,dl
move. w
d6,d2
move.w
d7,d3
nulls
py,d3
mu Is
pz,d2
sub.w
d2,d3
move.w
d3, rx
mu Is
pz,dl
mu Is
px,d7
sub. w
d7,dl
move.w
dl, ry
mu Is
px, d6
mu Is
py,d5
sub. w
d5,d6
move.w
d6, rz
move.w
prox,dl
sub.w
kx,dl
move. w
proy,d2
sub.w
ky,d2
move.w
proz,d3
* Here the two vectors, which lie
* in the surface plane, are
* determined by subtracting the
* coordinates of two points
* from this surface.
* The direction coordinates of the
* vectors are stored in the
* variables qx,qy,qz and px,py,pz
* Calculate vector Q
* qx
* qy
* qz
* Calculate the cross product
* of the vertical vector for the
* current surface.
* The direction coordinates of the
* vertical vector are stored
* zobsorarily in rx,ry,rz
* The projection center
* is used as the comparison
* point for the visibility
* of a surface.
* One can also use the
207
ST 3D Graphics
Abacus Software
sub. w
kz, d3
*
mu Is
rx, dl
*
mu Is
ry, d2
*
mu Is
rz, d3
*
add. 1
dl, d2
*
add. 1
d2,d3
*
bmi
dosight
*
* If the scalar product is negative.
move.w
(aO),dl
*
ext. 1
dl
lsl.l
#2, dl
*
addq.1
#2, dl
*
add. 1
dl, aO
*
sightl:
dbra
dO,visible
*
bra
hideend
*
dosight:
move. w
(aO),dl
*
ext. 1
dl
*
lsl.l
#1, dl
*
sight3:
move. w
(aO)+,(a5)+
*
dbra
dl,sight3
*
addq. w
#1, surfcount
*
bra
sightl
*
hideend:
rts
observation ref. point
as the comparison point. Now comes
the comparison of vector R with
the vector from a point on the
surface to the projection center
for creating the scalar product
of the two vectors.
the surface is visible
Number of lines of the surface
Number of lines times 4 = space for
lines plus 2 bytes for the number of
lines added to surface array, for
access to next surface. When all
surfaces completed then end.
Number of lines for this surface,
gives the number of words to be
transmitted when multiplied by 2.
pass the number of lines and the
the individual lines
the number of surfaces plus one
and process the next
* Draw visible surfaces passed in vplane *
surfdraw:
move.l xplot,a4
move.l yplot,a5
* Draws a number of surfaces (passed
* in surfcount) whose description
move.1
move.w
#vplane,a6
surfcount,dO
* is in the array at address
* vplane, and was entered by routine
208
Abacus Software
ST 3D Graphics
ext. 1
dO
* hideit
subq.1
#1, dO
* if no surface is entered in the
bmi
surfend
* array, then end.
surflopl:
move. w
(a6)+,dl
* Number of lines in this surface as
ext. 1
dl
* counter of lines to be drawn.
subq. 1
#1, dl
surflop2:
move. 1
(a6) +,d5
* First line of this surface
subq.w
#1, d5
* Access screen array which contains
lsl. w
#1, d5
* screen coordinates of the points.
move . w
0(a4,d5.w),d2
move. w
0(a5,d5.w),d3
* extract points from routine and
swap
d5
* pass.
subq.w
#1, d5
lsl .w
#1, d5
move.w
0 (a4,d5 .w) , a2
* second point of line
move.w
0(a5,d5.w),a3
jsr
drawl
* Draw line until all lines of this
dbra
dl,surflop2
* surface have been drawn and repeat
dbra
dO,surflopl
* until all surfaces are drawn.
surfend:
rts
* Return.
* Here begins the variable area of the program module *
* *
* *
* Definition of the house *
* *
.data
housdatx: .dc.w
• do. w
-30,30,30,-30,30,-30,-30,30,0,0,-10,-10,10,10
30,30,30,30,30,30,30,30,30,30,30,30
209
ST 3D Graphics
Abacus Software
housdaty:
.dc,
, w
30,
30,-30,-30,30,30,
-30,
-30,
70,
70,-
30,
o
to
1
o
o
. dc,
. w
20,
20, 0,0,20,20,0,0
. dc.
. w
-10
,-10,-30,-30
housdatz:
• dc.
, w
60,
60,60,60,-60,-60,
-60,
-60,
60,
-60,
60,
60, 60, 60
.dc,
. w
40,
10,10,40,-10,-40,
-40,
-10
. dc.
. w
o,-
20,-20,0
houslin:
. dc.
. w
1, 2
,2,3,3,4,4,1,2,5,
5,8,
8,3,
8, 7
,7, 6
, 6,
5, 6, 1,7,4
. dc.
, w
9, 10,1, 9, 9,2,5,10, 6,
10,11,12
, 12
,13,
13,
14
. dc,
. w
15,
16,16,17,17,18,18
,15,
19,20,20,21
,21
,22,22,19
. dc.
. w
23,
24,24,25,25,26,26
,23
* here are the definitions of the surfaces belonging to the house *
houspla: .dc.w
.dc. w
.dc.w
.dc.w
.dc.w
.dc.w
• dc.w
hnummark:
.dc.w
hnumline:
.dc.w
hnumsurf:
.dc.w
hxangle:
.dc.w
hyangle:
.dc.w
hzangle:
.dc.w
xwplus:
.dc.w
ywplus:
.dc.w
zwplus:
.dc.w
picturex:
.dc.w
picturey:
.dc.w
4,1,2,2,3,3,4,4,1,4,2,5,5,8,8,3,3,2
4,5,6, 6, 7, 7,8, 8,5, 4,7,6, 6,1,1, 4,4,7
4,4,3,3,8, 8,7, 7,4,4,2,9, 9,10, 10,5, 5,2
4,10,9,9,1,1,6,6,10,3,1,9,9,2,2,1
3,5,10,10,6,6,5,4,11,12,12,13,13,14,14,11
4,15, 16, 16, 17, 17, 18, 18, 15,4, 19, 20,20, 21,21, 22, 22, 19
4,23,24,24,25,25/26,26,23
26 * Number of corner points of the house
32 * Number of lines of the house
13 * Number of surfaces of the house
0 * Rotation angle of house about X-axis
0 * " " Y-axis
0 * " " Z-axis
0 * Angle increment about X-axis
0 * Angle increment about Y-axis
0 * Angle increment about Z-axis
0 * Definition of zero point of display
0 * entered by getreso
210
Abacus Software
ST 3D Graphics
rotdpx:
• dc. w
0
rotdpy:
. dc. w
0
rotdpz:
.dc. w
0
rlzl:
. dc. w
0
normz:
.dc. w
1500
.bss
plusrot:
. ds. 1
1
first:
.ds.w
1
second:
.ds. w
1
deltal:
.ds.w
1
worldpla:
.ds. 1
1
* Address of surface array
.data
plag:
.dc .b
1
.even
.bss
diffz:
.ds.w
1
dx:
.ds.w
1
dy:
.ds.w
1
dz:
.ds.w
1
wrldx:
.ds.w
1600
* World coordinate array
wrldy:
.ds.w
1600
wrldz :
.ds.w
1600
viewx:
.ds.w
1600
* View coordinate array
viewy:
.ds.w
1600
viewz:
.ds.w
1600
screenx:
.ds.w
1600
* Display coordinate array
screeny:
.ds.w
1600
211
ST 3D Graphics
Abacus Software
wlinxy:
• ds. 1
3200
* Line array
wplane:
.ds. 1
6600
* Surface array
vplane:
.ds. 1
6600
* Surface array of visible surfaces
surfcount:
• ds. w
1
numsurf:
• ds. w
1
zcount:
. ds. 1
1
* Sum of all Z-coordinates
zpla:
. ds. w
1
* Individual Z-coordinates of surface
sx:
. ds. w
1
sy:
.ds .w
1
sz:
.ds .w
1
px:
.ds. w
1
py:
• ds. w
1
pz:
• ds. w
1
rx:
.ds. w
1
ry:
.ds. w
1
rz:
. ds. w
1
qx:
.ds .w
1
qy:
-ds. w
1
qz:
.ds. w
1
kx:
-ds. w
1
ky:
.ds. w
1
kz:
.ds. w
1
. data
prox:
.dc.w
0
* Coordinates of the projection center
proy:
. dc. w
0
* on the positive Z-axis
proz:
.dc.w
1500
212
Abacus Software
ST 3D Graphics
.data
of fx:
. dc. w
0
*
Transformation during rotation
of fy:
.dc. w
0
*
to point [offx,offy,offz]
of f z:
. dc. w
0
xoffs:
.dc. w
0
*
Inverse transformation to point
yoffs:
. dc. w
0
★
[xoff,yoffs, zoffs]
zoffs:
.dc. w
0
.bss
loopc
.ds. 1
. end
1
213
ST 3D Graphics
Abacus Software
4.3.1 Explanation of the newly-added subroutines
hideit: In contrast to the explanation in the mathematical part, the
view system used by the program is a right system; this
saves the multiplication of the Z-values by -1. The
subroutine hideit forms two vectors within the surface
from the first three points of every surface. These are the
vectors from point one to point two as well as the vector
from point one to point three. These two vectors
correspond to the vectors P[px,py,pz] and
Q[qx,qy,qz] from chapter 2.7. Furthermore, a third
vector R[rx,ry,rz] is generated through the formation
of the cross product of the vectors P and Q. According to
the definition, the cross product is perpendicular to the
vectors P and Q and, in this sequence forms a right-hand
system with them [p, q, r]. Finally, a vector is created
from a point on the surface to the projection center
(S[sx,sy,sz]), and its direction is compared with the
direction of the vector R by creation of the scalar products
of the vectors S and R. All the surfaces which are in front
of the projection center are visible.
Scalar product= sx*rx+sy*ry+sz*rz =
!s|*|r|*cos(Alpha)
Alpha is the angle suspended between the vectors R and S.
If the result of the scalar product is negative, this means an
angle larger than 90 degrees and smaller than 270 degrees
between the two vectors, which point in different
directions (See also Figure 2.7.1), and so this surface is
visible, according to the surface definition (clockwise
direction) and right system used.
surf dr aw: Here the visible surfaces are displayed by drawing the
lines of the array vplane. The whole job was done
already by hideit.
The operation parameters of the program are the same as in house 1. s,
The rotation point on the Z-axis can be moved with the * and / keys on
the keypad, the projection plane can be moved with the - and + keys on
the keypad, and the angle increments of the rotation angle around the X
214
Abacus Software
ST 3D Graphics
and Y-axis can be changed with the cursor keys and the Help and Undo
keys. Of course you can also change all the parameters within the
program (projection center, rotation reference point to X and Y-axis,
etc.).
4.3.1.1 Errors with non-con vex bodies
If the rotation creation routine is added to the main program and the chess
figure is created with hideit: and pladraw without hidden lines: you
can see the problem. With concave bodies such as this chess figure there
is the possibility that one of the surfaces recognized by the hideit:
algorithm as visible can be hidden by another visible surface during
viewing. In this case the hideit: algorithm fails and the problem must
be solved with another algorithm.
215
ST 3D Graphics
Abacus Software
4.4 The painter algorithm
Recall the problem we‘re trying to solve: Surfaces which are seen from
an observation point have their surface normal vector pointed in another
direction from a vector from any point on the surface to the projection
center, are hidden by other surfaces which according to this criterium are
also visible. If you start from the observation point (projection center) on
the positive Z-axis, the middle Z-coordinate of a surface is a possible
description of it and its position in the world system. The middle Z-
coordinate is obtained by defining the arithmetic center of the comer
point coordinates belonging to the surface, i.e. summation of all surface
comer point Z-coordinates and division by the number of comer points
belonging to the surface. The relationship can be made clear with the
simple example with three different surfaces in Figure 4.4.1.
216
Abacus Software
ST 3D Graphics
Viewing the defined world system from one point on the positive Z axis,
we can say: the surface with the largest middle Z-coordinate is visible in
its entire size and is not hidden by any other surface. Note that all
observed surfaces are on the negative Z-axis (-200 > -400). This
completely visible surface covers parts of surfaces with a smaller middle
Z coordinate. Surfaces 2 and 3 are covered by surface 1 and surface 3 is
again covered by surface 2. The surfaces are sorted by their Z-coordinates
and they are drawn starting with the smallest middle z-coordinate, surface
3, and then the surfaces with the larger Z coordinates, and we have found
a possible solution to the problem by covering hidden surfaces with other
surfaces. You must consider that it is not enough just to draw every
surface. The individual surfaces must be filled with "color" or a pattern so
that the surfaces drawn first are really covered. Figure 4.4.2 shows one
possible result
+ Y
Figure 4.4.2
If we think about our rotation body from chapter 4.2, this means first of
all that when the rotation body is created its surfaces must also be
217
ST 3D Graphics
Abacus Software
created, second a middle Z coordinate must be calculated and stored
some place for every surface. Another problem is sorting the surfaces. If
one wanted to sort every defined form with its lines, it would require an
enormous movement of data in storage. To avoid this, a new storage area
is created in which the Z-coordinates together with the beginning address
of the surface it pertains to are stored. The individual surfaces are stored
in a simple linear list. The beginning address of every surface is the
storage address at which the number of lines for this surface is stored.
Through storage of this address, it is possible to access every single
surface directly, which previously was not possible because of the
number of lines belonging to each surface.
To better handle the two pieces of information, (Z-coordinates of the
surface and address of the surface) we select a long word as data size for
both, i.e. in the newly constructed array (surfaddr) there are four
successive bytes for the Z-coordinate and four bytes for the address of the
surface. Each description of a surface "occupies" eight bytes of storage
space. This array contains the visible surfaces represented by their middle
Z-coordinates and their beginning addresses in the new addition to the
subroutine hide it: (sight 2). In this special case of the rotation body
whose surfaces all consist of four lines, the division by the line number
(4) for calculation of the middle Z-coordinate can be performed by
shifting right by two bit positions. If you want to include surfaces with
more or less than four lines in the paint routine, you must alter the
hide it -routine and divide by the number of surfaces. After the
adaptation of the subroutine hideit: all visible surfaces are in the two
arrays, in vplane: and in surfaddr:. The number of surfaces, like in
the first version of hideit:, goes in the variable placount:.
Fortunately, we do not have to write the shading function since the
operating system offers a function for filling display areas with a shading
pattern (Filled Area). This function fills a polygon whose points are
passed in the ptsin array, with one of a total of 36 different predefined,
and one user-defined shading pattern. Before calling this function with
the opcode 9, we set up the different shading parameters which is done
using the subroutines filmode, filform, filcolor, filstyle
and f ilindex which are contained in the link file (grlink 1).
The shading routine is called by the subroutine paint it, which first
sorts all surfaces contained in surfaddr: according to ascending Z-
coordinates. Next you must pass the individual surfaces, i.e. their end
point coordinates, to the function "Filled Area". This begins with the
surface which has the smallest middle Z-coordinate. The function "Filled
218
Abacus Software
ST 3D Graphics
Area" can, in connection with the function "Set Clipping Rectangle",
Opcode 129, fill surfaces limited to a display window. It is necessary to
call the function "Set Clipping Rectangle" when the display window is
the total screen area, bordered by the coordinates 0,0 and 639,399 (for
BW monitors), if this is not done, "Filled Area" may draw parts of the
polygon sticking beyond the display frame on the neighboring display
page (wrapping). You could fill all surfaces with the same pattern, which
could also be white. You can assign a shading pattern for every surface
corresponding to its Z-coordinates. We will limit ourselves to only six of
the 36 possible fill patterns. This is done purely for optical reasons since
shaded surfaces, and even completely filled color surfaces, can have a
negative effect on the picture. You can influence this choice or omit it
entirely. Simply set the desired pattern on entry to the subroutine. With a
color monitor, a various fill colors can be used instead of a shading
pattern. The choice of colors is completely up to you. The visual effect of
these three-dimensional graphics can best be appreciated with a high-
resolution monitor. Doubling the resolution in both directions increases
the quality of the picture four times.
If you have a color monitor, you can choose between filling with color or
patterns. If you want to try filling with color you must call the function
filstyle with the value one in the DO register when entering the
paint it routine. The subroutine filcolor: makes it possible to use
different colors. Owners of monochrome monitors don’t have to change
anything in the program. To run this program call the batch file batch.ttp
then enter: as link grlinkl paintl
253882 bytes used 1
Si PRINTERS
Si TUTORIAL
C FRY
COM TTP
NLlfl PRG
OUTPUT PRG
SPLIT TTP
STRNDARD PRT
TEXTPRO PRG
TUTORIAL TXT
XTTUTORI TOC
1442236 bytes used in 125 itens
38944
OPEN APPLICATION
Mane: BATCH .TTP
Paraneters:
aslink grlinkl paintlj—_
1
F:\3DM0RK.DIR\
333956 butes used in
H0USE1 PRG
H0USE1 S
HAIN1 PRG
HRIN1 S
MAIK1C0 PR6
MAIN1C0 S
HENU1 PRG
MENU1 S
MULTI1 PRG
MULTI1 S
PAINT1 PRG
PAINT1 S
R0TATE1 PRG
R0TATE1 S
ST 3D Graphics
Abacus Software
Figure 4.4.3
Here is the listing of the fourth main program for the link file
grlinkl.s. It is called paintl.s. The operating parameters again
correspond to the previous program.
220
Abacus Software
ST 3D Graphics
**********************************************************************
* paint 1.s 9.2.1986 *
* Display a shaded rotation body *
* *
★*********************************************************************
.text
.globl main,xoffs,yoffs, zoffs,offx,offy,offz
.globl viewx,viewy,viewz
.globl wlinxy,mouse_off,setrotdp,inp_chan,pointrot
main:
jsr
apinit
*
Announce program
jsr
grafhand
*
Get screen handler
jsr
openwork
*
open workstation
jsr
mouseoff
*
Turn off mouse
jsr
getreso
*
Display resolution ?
jsr
setcocli
*
Set clip window
jsr
makerotl
*
Create rotation body
jsr
makewrld
*
Create world system
jsr
wrld2set
★
Pass world parameters
jsr
setrotdp
★
initialize observation ref. point
jsr
clwork
jsr
pagedown
*
Display logical page
jsr
clwork
jsr
inp chan
mainlopl:
jsr
pointrot
*
rotate around observ. ref. point
jsr
pers
*
Perspective transformation
jsr
hideit
★
hide hidden surfaces
jsr
paintit
★
sort and shade
jsr
pageup
*
Display physical page
jsr
inp chan
*
Input new parameters
jsr
clwork
★
clear screen page not displayed
jsr
pointrot
*
Rotate around rot. ref. point
jsr
pers
★
Transform new points
jsr
hideit
*
hide
jsr
paint it
*
sort and shade
221
ST 3D Graphics
Abacus Software
jsr
pagedown *
Display this logical page
jsr
inp chan *
Input and change parameters
jsr
clwork *
erase physical page
jmp
mainlopl *
to main loop
move. 1
physbase,logbase
jsr
pageup *
Switch to normal screen page
rts
★
back to link file and end
A**********************************************************************
* Creation of rotation body by passing parameters *
* and calling rotation routine *
it**********************************************************************
makerotl: jsr
jsr
rts
rlset * Set parameters of rot. body
rotstart * and create rot. body
* Input and change parameters with the keyboard *
inp__chan:
jsr
inkey
cmp .b
#'D',dO
bne
inpwait
jsr
scrdmp
inpwait:
swap
dO
cmp .b
#$4d,dO
bne
inpl
addq. w
#1,ywplus
bra
inpendl
inpl:
cmp .b
#$4b,dO
bne
inp2
subq. w
#1,ywplus
bra
inpendl
* Read keyboard, code in
* Make hardcopy
* Test DO for
* Cursor-right
* if yes, add one to
* Y-angle increment and continue
* Cursor-left, if yes
* subtract one from
* Y-angle increment
222
Abacus Software
ST 3D Graphics
inp2 :
cmp .b
#$50,dO
bne
inp3
addq. w
#1, xwplus
bra
inpendl
inp3:
cmp .b
#$48,dO
bne
inp3a
subq.w
#1,xwplus
bra
inpendl
inp3a:
cmp .b
#$61,dO
bne
inp3b
subq.w
#1,zwplus
bra
inpendl
inp3b:
cmp -b
#$62,dO
bne
inp4
addq.w
#1,zwplus
bra
inpendl
inp4 :
cmp.b
#$4e,dO
bne
inp5
sub. w
#25,dist
bra
inpendl
inp5:
cmp.b
#$4a,dO
bne
inp6
add. w
#25,dist
bra
inpendl
inp6:
cmp.b
#$66,dO
bne
inp7
sub. w
#15,rotdpz
bra
inpendl
inp7 :
cmp.b
#$65,dO
bne
inplO
add. w
#15,rotdpz
bra
inpendl
* Cursor-down, if yes
* add one to X-angle
* increment
* Cursor-up
* subtract one
* Undo key
* decrease Z-increment
* Help key
* increase Z-increment
* + key on keypad
* if yes, subtract 25 from
* location of projection
* plane (Z-coordinate)
* minus key on keypad
*
* if yes, add 25
* * key on keypad
* if yes, subtract 15 from
* rotation point Z-coordinate
* Make change
* / key on keypad
* add 15
223
ST 3D Graphics
Abacus Software
inplO:
cmp .b
#$44,dO
*
F10 pressed ?
bne
inpendl
addq. 1
#4,a7
*
if yes, then jump to
bra
ma inend
*
program end
inpendl:
move. w
hyangle, dl
*
Rotat.angle about Y-axis
add. w
ywplus,dl
★
add increment
cmp. w
#360,dl
*
if larger than 360, then
bge
inpend2
*
subtract 360
cmp. w
#-360,dl
*
if smaller than 360, then
ble
inpend3
*
add 360
bra
inpend4
inpend2:
sub. w
#360,dl
bra
inpend4
inpend3:
add. w
#360,dl
inpend4:
move. w
dl,hyangle
move. w
hxangle,dl
*
do the same for
add. w
xwplus,dl
★
the rotation angle
cmp. w
#360,dl
★
about X-axis
bge
inpend5
cmp. w
#-360,dl
ble
inpend6
bra
inpend7
inpend5:
sub. w
#360,dl
bra
inpend7
inpend6:
add. w
#360,dl
inpend7:
move.w
dl,hxangle
*
move.w
hzangle,dl
add. w
zwplus,dl
cmp.w
#360,dl
bge
inpend8
cmp. w
#-360,dl
ble
inpend9
bra
inpendlO
inpend8:
sub. w
#360,dl
bra
inpendlO
inpend9:
add. w
#360,dl
224
Abacus Software
ST 3D Graphics
inpendlO: move.w dl,hzangle
rts
* Initialize the rotation reference point to [0,0,0] *
move.w
#0, dl
* set the Initial rotation
move.w
dl,rotdpx
* ref. point
move. w
dl,rotdpy
move.w
dl,rotdpz
move. w
#0,hyangle
* initial rotation angle
move.w
#0,hzangle
move.w
#0,hxangle
rts
* Rotation around the rotation reference point about all *
* three axes *
pointrot: move.w
hxangle,xan
gle
* rotate the world around
move.w
hyangle,yangle
move.w
hzangle,zangle
move.w
rotdpx,dO
* rotation reference point
move.w
rotdpy,dl
move. w
rotdpz,d2
move.w
dO,xoffs
*
add for inverse transform
move.w
dl,yoffs
move. w
d2,zoffs
neg. w
dO
neg. w
dl
neg. w
d2
move.w
dO,of fx
*
subtract for transform
move.w
dl,offy
move.w
d2,offz
jsr
matinit
*
initialize matrix
jsr
zrotate
■k
rotate first about Z-axis
jsr
yrotate
*
rotate 'matrix' about Y-axis
jsr
xrotate
*
then rotate about X-axis
jsr
rotate
*
Multiply points with matrix.
rts
225
ST 3D Graphics
Abacus Software
***********************************************************************
* Create world system by copying the object data into world system *
***********************************************************************
makewrld:
makewll:
makewl2:
makew!3:
makewl4:
move. 1
#rldatx,al
* Create world system by
move.1
#rldaty,a2
move.1
trldatz,a3
move.1
#wrldx,a4
move. 1
#wrldy,a5
move.1
#wrldz,a6
move.w
rlnummark,dO
ext. 1
dO
subq.1
#l,dO
move.w
(al)+, <a4)+
* copying point coordinates
move.w
(a2)+, (a5) +
* into the world system
move.w
(a3)+, <a6)+
dbra
dO,makewll
move.w
rlnumline,dO
ext. 1
dO
subq.1
#l f dO
move.1
#rllin,al
move.1
#wlinxy,a2
move.1
(al)+, (a2) +
* Copy lines into world
dbra
d0,makewl2
* system
move.1
worldpla,aO
move.1
#wplane,al
move.w
rlnumsurf,dO
ext. 1
dO
subq.1
#1, dO
move.w
(aO)+,dl
* Copy surfaces into
move.w
dl, (al) +
* world system
ext. 1
dl
subq.1
#1 / dl
move.1
(aO)+,(al)+
* Copy every line of
dbra
dl,makewl4
* this surface into
dbra
dO,makewl3
* world array until all
rts
* surfaces are completed
226
Abacus Software
ST 3D Graphics
*********************************************************************
* Pass the world parameters to the variables in the *
* link files
*********************************************************************
wrldset:
move.1
#wrldx,datx *
move. 1
#wrldy,daty *
move.1
#wrldz,datz *
move.1
#viewx,pointx
move.1
#viewy,pointy
move.1
#viewz,pointz
move.1
#wlinxy,linxy
move. w
picturex,xO
move.w
picturey,yO
move.w
proz,zobs
move.w
rlzl,dist
move.1
Iscreenx,xplot
move.1
#screeny,yplot
move.w
hnumline,numline
move.w
hnummark,nummark
move.w
rts
hnumsurf,numsurf
Pass the variables
for the rotation
routine
* Remove all characters from keyboard buffer
clearbuf:
move. w
#$b,-(a7)
trap
#1
addq. 1
#2, a7
tst. w
dO
beq
clearnd
move.w
#1,-{a7)
trap
#1
addq.1
#2, a7
bra
clearbuf
clearnd:
rts
227
ST 3D Graphics
Abacus Software
*********************************************************************
* Sense display resolution and set coordinate *
* origin to screen center *
*********************************************************************
getreso:
move.w
#4,-(a7)
*
Sense display resolution
trap
#14
addq.1
#2,a7
cmp. w
#2, dO
bne
getrl
move.w
#320,picturex
★
Monochrome monitor
move.w
#200,picturey
bra
getrend
getrl:
cmp • w
#1, dO
bne
getr2
move.w
#320,picturex
*
medium resolution (640*200
move.w
#100,picturey
bra
getrend
getr2:
move.w
#160,picturex
*
low resolution (320*200)
move.w
#100,picturey
getrend:
rts
* Hardcopy of screen, called by inp_chan *
* *
scrdmp:
move. w
trap
addq. 1
jsr
rts
#20,-(a7)
#14
#2,a7
clearbuf
228
Abacus Software
ST 3D Graphics
*********************************************************************
* Sets the limits of the display window for the
* Cohen-Sutherland clipping algorithm built into the
* draw-line algorithm
* The limits can be freely selected by the user which makes ‘
* the draw-line algorithm very flexible. *
*********************************************************************
move.w
#0, clipxule
move . w
#0,clipyule
move.w
picturex,dl
lsl. w
#l,dl
★
times two
subq.w
#l,dl
★
minus one equals
move.w
dl,clipxlri
*
639 for monochrom
move .w
picturey,dl
lsl. w
#1, dl
*
times two minus one
subq.w
#1, dl
*
equals 399 for monochrome
move.w
dl,clipylri
rts
* Pass visible surfaces into vplane array and
* into pladress array for subsequent sorting
*r
* of surfaces
hideit:
move. w
numsurf, dO
*
Number of surfaces as
ext. 1
dO
*
counter
subq.1
#1, dO
move.1
#viewx,al
*
The point
move.1
#viewy,a2
*
coordinates are stored here
move.1
#viewz,a3
move.1
#wplane,aO
*
Here is the information
move.1
fvplane,a5
*
for every surface
move.w
#0,surfcount
*
Counts the known visible surfaces.
move.1
tpladress,a6
*
Address of surface storage
move.w
(aO) ,dl
*
Start with first surface
ext. 1
dl
*
Number of points on this surface in Dl
move. w
2 (aO),d2
*
Offset of first point of this surface
229
ST 3D Graphics
Abacus Software
A
doit 1:
move.w
4 <a0),d3
*
Offset of second point
move.w
8 (aO),d4
*
Offset of third point
subq.w
#l,d2
*
For access to point array
subq.w
#1, d3
*
subtract one from current
subq.w
#1, d4
*
point offset.
lsl. w
#1/ d2
*
Multiply by two
lsl. w
#l,d3
lsl -w
#1, d4
★
and access current
move. w
(al,d3.w),d6
*
point coordinates
cmp. w
(al,d4.w), d6
*
Comparison recognizes two point
bne
doit 1
★
with the same coordinates
★
created through
move.w
(a2,d3.w) ,d6
*
construction of
cmp. w
(a2,d4.w) ,d6
★
rotation bodies. When
bne
doitl
★
two points are found
move.w
(a3,d4.w),d6
★
where all point coordinates (x.
cmp. w
(a3,d3.w),d6
★
match, the program selects the
bne
doitl
*
third point to find
move. w
12(aO),d4
*
both vectors
subq.w
#l,d4
lsl .w
#l,d4
move.w
(al,d3.w),d5
*
the two vectors which
move.w
d5, kx
*
lie in the surface plane
sub.w
(al,d2.w),d5
*
are found by subtracting the
move.w
d5,px
*
coordinates of two points
move.w
<a2,d3.w),d5
*
in this surface
move.w
d5, ky
*
the direction coord, of the
sub. w
<a2,d2.w),d5
*
vectors is stored in
move. w
d5,py
*
variables qx,qy,qz and
move. w
(a3,d3.w),d5
*
px,py,pz
move. w
d5, kz
sub. w
(a3,d2.w),d5
move.w
d5, pz
move.w
(al,d4.w),d5
*
Calculate vector Q
sub. w
(al,d2.w),d5
move.w
(a2,d4.w),d6
sub. w
(a2,d2.w),d6
move.w
(a3,d4.w),d7
sub. w
(a3,d2.w),d7
230
Abacus Software
ST 3D Graphics
move. w
d5,dl
* qx
move.w
d6,d2
* qy
move.w
d7,d3
* qz
mu Is
py,d3
* Compute cross product
mu Is
pz, d2
* of the vector perpendicular
sub.w
d2,d3
* to the current surface
move. w
d3, rx
mu Is
pz, dl
mu Is
px,d7
sub.w
d7, dl
* The direction coordinates of
move.w
dl, ry
* the vector perpendicular to
mu Is
px, d6
* the surface are stored
mu Is
py,d5
* in rx,ry,rz
sub - w
d5,d6
move. w
d6, rz
move. w
prox,dl
* The projection center serves as
sub.w
kx, dl
* comparison point for the visibility
move .w
proy,d2
* of a surface which seems
sub.w
ky,d2
* adquate for the viewing
move. w
proz,d3
* situation. The observation
sub.w
kz, d3
* ref. point can also
mu Is
rx, dl
* be used as the comparison point.
muls
ry,d2
* Compare vector R and
mu Is
rz, d3
* the vector from one
add. 1
dl,d2
* point of the surface to
add. 1
d2,d3
* the projection center by forming
bmi
dosight
* the scalar product of the two vector:
scalar product is negative, surface is visible
move.w
(aO),dl
*
Number of lines in surface
ext. 1
dl
lsl.l
#2, dl
★
Number of lines times 4 = space for line
addq.1
#2, dl
*
plus 2 bytes for number of lines
add. 1
dl, aO
★
add to surface array for
dbra
dO,visible
*
access to next surface
bra
bideend
*
All surfaces processed ? End
231
ST 3D Graphics
Abacus Software
dosight: move.w (aO),dl * Number of lines for this surface
ext.1 dl * multiplied by two results in
*************
** Changes from the program rotl.s
* *
**********************************
move.1 dl,d2
lsl.l #l,dl
move.l a0,a4
addq.l #2,a4
move.w #0,zsurf
sight2: move.l (a4)+,d6
swap d6
subq.w #l,d6
lsl.w #1,d6
move.w (a3,d6.w),d6
add.w d6,zsurf
dbra d2,sight2
move.w zsurf,d6
★
ext.l d6
lsr.l #2,d6
ext.l d6
move.1 d6, (a6) +
move.1 aO, (a6) +
sight3: move.w (a0)+, (a5) +
dbra dl,sight3
addq.w #1,surfcount
bra sight 1
hideend: rts
* it
* *
* Number of words to be passed
* Access to first line of the surface
* Clear addition storage
* first line of surface
* first point in lower half of DO
* fit index
* fit operand size (2-Byte)
* Z-coordinate of this point
* add all Z-coordinates
* until all lines are computed
* Divide sum of all Z-coordinates
* for this
* surface by the number of lines
* Surfaces created by rotation
* always have four lines.
* Store middle Z-Coordinate
* followed by address of surface
* pass number of lines
* and individual lines
* increase number of surfaces by one
* and work on next surface
232
Abacus Software
ST 3D Graphics
***********************************************************************
* Create rotation body by passing parameters, *
* rotating the definition line, and creating the line and
* surface arrays *
***********************************************************************
rlset:
move.1
#rlxdat,rotxdat
*
Pass the
move. 1
#rlydat,rotydat
*
parameters for
move.1
#rlzdat,rotzdat
*
rotation body to
move.1
#rldatx,rotdatx
*
routine for
move.1
#rldaty,rotdaty
*
creating the
move.1
#rldatz,rotdatz
★
rotation body
move.1
rotdatx,datx
*
array addresses of
move.1
move. 1
rotdaty,daty
rotdatz,datz
★
the points
move.w
rlnumro,numro
★
Number of desired rotations
move. w
rlnumpt,numpt
★
Number of points to be rotated
move.1
#rllin,linxy
★
Address of line array
move.1
rts
#rlplane,worldpla
*
Address of surface array
rotstart: move.w numpt,dO
lsl.w #l,dO
ext.1 dO
move.1 dO,plusrot
move.w numpt,nummark
move.1 rotdatx,pointx
move.1 rotdaty,pointy
move.1 rotdatz,pointz
move.w #0,yangle
move.w #360,dO
divs numro,d0
move.w dO,plusagle
move.w numro,d0
ext.l dO
rloopl: move.1 d0,loopc * as loop counter
move.l rotxdat,datx
move.1 rotydat,daty
move.l rotzdat,datz
jsr yrot * rotate
* Rotation of def line
* numro+1 times about Y-axis
* Storage for one line
* Number of points
* rotated
* 360 / numro = angle increment
* per rotation
* store
* numro +1 times
233
ST 3D Graphics
Abacus Software
rotlin:
rotlopl:
rotlop2:
move.1
pointx,dl
* add offset
add. 1
plusrot,dl
move.1
dl,pointx
move.1
pointy, dl
add. 1
plusrot,dl
move. 1
dl,pointy
move. 1
pointz,dl
add. 1
plusrot,dl
move.1
dl,pointz
move.w
yangle,d7
add.w
plusagle,d7
move. w
d7,yangle
move.1
loopc,dO
dbra
dO,rloopl
move.w
rlnumro,numro
move.w
rlnumpt,numpt
jsr
rotlin
* Create line array
jsr
rotsurf
* Create surface array
rts
move.w
#1, d7
move. w
numro,d4
* *
Number of rotations
ext .1
d4
subq.1
#1, d4
move. w
numpt,dl
★
Number of points in def. lin
subq.w
#1, dl
*
both as counters
lsl. w
#2,dl
★
times two
ext. 1
dl
move.1
dl,plusrot
move.w
numpt,d5
★
Number of points minus once
ext. 1
d5
*
repeat, last line
subq.1
#2,d5
★
connect points (n-l,n)
move.1
linxy,al
move.w
d7,d6
move.w
d6, (al) +
★
first line connects
addq.w
#l,d6
★
points (1,2) then (2,3) etc.
move.w
d6, (al) +
dbra
d5,rotlop2
234
Abacus Software
ST 3D Graphics
move.1
linxy,dl
add. 1
plusrot,dl
move . 1
dl,linxy
move .w
numpt,dO
add. w
d0,d7
dbra
d4,rotlopl
move . w
numpt,d7
move.w
d7,deltal
lsl. w
#2,d7
ext. 1
d7
move . 1
d7,plusrot
move. w
#1, d6
move.w
numpt,dO
ext. 1
dO
subq.1
#l,dO
rotlop3:
move.w
numro,dl
ext. 1
dl
subq.1
#1, dl
move. w
d6, d5
rotlop4 :
move . w
d5,(al)+
★
generate cross
add. w
deltal,d5
*
connection lines which
move. w
d5, (al) +
*
connect lines created
dbra
dl,rotlop4
★
by rotation
add.w
#1, d6
dbra
dO,rotlop3
move.w
numro,dl
add. w
#1, dl
mu Is
nummark, dl
move. w
dl,rlnummark
move.w
numpt,dl
mu Is
numro,dl
move. w
numpt,d2
subq.w
#1, d2
mu Is
numro,d2
add.w
dl, d2
235
ST 3D Graphics
Abacus Software
move.w d2,rlnumline * store number of lines
rt s
rotsurf:
move.w
numro,dO
ext. 1
dO
subq.1
#1, dO
move.w
numpt,d7
ext. 1
d7
subq.1
#2,d7
move.1
d7,plusrot
move.1
worldpla,aO
move.w
#1/ dl
move. w
numpt,d2
addq.w
#l,d2
rotf11:
move.1
plusrot,d7
rotf12:
move.w
dl, d4
move.w
d2,d5
addq.w
#l,d4
addq.w
#1, d5
move.w
#4, (aO) +
move.w
dl, (aO) +
move.w
d4, (aO) +
move.w
d4, (aO) +
move.w
d5,(aO)+
move.w
d5,(aO)+
move.w
d2,(aO)+
move.w
d2, (aO) +
move.w
dl, (aO) +
addq.w
#1, dl
addq.w
#1, d2
dbra
d7,rot f12
addq.w
#1, dl
addq.w
#1, d2
dbra
dO,rotf11
move.w
numpt, dl
subq.w
#1, dl
muls
numro,dl
* Create surfaces of
* rotation body
* Number of points minus one
* repeat
* Address of surface array
* Number of points
* Offset
* Number of lines/surfaces
* first surface created here
236
Abacus Software
ST 3D Graphics
move.w dl,rlnumsurf
rts
* Pass data and parameters to the link file routines
wrld2set: move.1
move -1
move.1
move.1
move.1
move . 1
move.1
move. w
move. w
move.w
move.w
move. 1
move. 1
move.w
move.w
move.w
rts
#wrldx,datx
#wrldy,daty
#wrldz,datz
#viewx,pointx
#viewy,pointy
#viewz,pointz
#wlinxy,linxy
picturex,xO
picturey, yO
proz,zobs
rlzl,dist
#screenx,xplot
#screeny,yplot
rlnumline,numline
rlnummark,nummark
rlnumsurf,numsurf
* Sort surfaces stored in pladress
sort it:
move. 1
#pladress,aO
move. w
surfcount,d7
ext. 1
d7
subq. 1
#2, d7
bmi
serror
move. 1
#l,dl
sortmain:
move . 1
dl, d2
subq.1
#l,d2
move.1
dl, d3
lsl.1
#3, d3
***********************************
★
***********************************
* for i = 2 to n corresponds to
* for i = 1 to n-1 because of
* different array structure
* j = i -1
* i
237
ST 3D Graphics
Abacus Software
move.1
(a0,d3.1) ,d5
*
Comparison value x = a[i]
move.1
4(aO,d3.1),d6
h
Address of surface
move. 1
d5,platz
*
a [0] = x = a [-1] in
move.1
d6,platz+4
*
this array
sortlopl:
move.1
d2, d4
*
j
lsl.l
#3, d4
*
j times 8 for access to array
cmp. 1
(aO,d4.1),d5
*
Z-coordinate of surface
bge
sortwl
*
while x < a[j] do
move. 1
(aO, d4.1), 8(aO,d4
1.1) * a [ j + 1] = a [ j]
move.1
4(aO,d4.1),12(aO,
d4.1) * Address of surface ar:
subq.1
#1, d2
* j = 3-1
bra
sortlopl
sortwl:
move. 1
d5, 8 (aO, d4.1)
*
a Cj+1] = x
move. 1
d6, 12(aO,d4.1)
*
pass address also
addq. 1
#1, dl
*
i = i + 1
dbra
d7, sortmain
*
until all surfaces are sorted
sortend:
rts
serror:
rts
*
On error simply return
* Fill surfaces stored in pladress *
paintit:
jsr
setclip
*
GEM clipping routine for Filled Area
jsr
sortit
Hr
Sort surfaces according to Z-coords.
move.w
#1, dO
*
Write mode to replace
jsr
filmode
jsr
filform
*
border filled surfaces
jsr
filcolor
*
Fill color is one
move.w
#2,dO
★
Fill style
jsr
filstyle
move.1
xplot,al
*
Address of screen coordinates
move.1
yplot,a2
move.w
surfcount,d7
* Number of surfaces to be filled
ext. 1
d7
Hr
as counter
subq.1
#1/ d7
*
access to last surface in the array
move.1
d7, dO
*
multiply by eight
lsl.l
#3, dO
238
Abacus Software
ST 3D Graphics
pa inti:
paint2:
paint3:
move.1
#pladress,aO * here
are the surfaces
move.1
(a0,d0.1),d5 * largest Z-coordinate
move. 1
#0, dl
move. 1
(aO,dl.1), d6 * first surface in array
neg. 1
d6 * smallest Z-coordinate
add. 1
d6,d5 * subtract from each other
move. 1
d5,d0
move.1
(a0,dl.l),d2 * first surface in array
add. 1
d6, d2 * plus
smallest Z-coordinate
lsl.l
#3,d2 * times eight, eight different
divs
d0,d2 * fill
patterns, divide by difference
neg.w
d2 * leave out last pattern
add. w
#6,d2
bpl
paint2
move.w
#1, d2
move•w
d2,d0
* Set fill index
jsr
filindex
move. 1
#ptsin,a3
* Enter points here
move. 1
4(a0,dl.l),a6
* Address of surface
move. w
(a6)+,d4
* Number of lines
addq. w
#1, d4
* first point counts double
move. w
d4,contrl+2
move. 1
(a6)+,d3
* first line of surface
swap
d3
subq.w
#1, d3
lsl. w
#1, d3
move.w
(al,d3.w),(a3)+
* transfer to ptsin array
move.w
(a2, d3 . w) , (a3) +
* transmit Y-coordinate
swap
d3
sub. w
#l,d3
lsl. w
#1, d3
move.w
(al, d3 . w) , (a3) +
* transmit next point
move.w
(a2,d3 .w) ,(a3)+
* transmit Y-coordinate
subq.w
#3,d4
* two points already transmitted
ext. 1
d4
* one because of dbra
move.1
(a6)+,d3
* next line
subq.w
#1, d3
lsl -W
#1, d3
move.w
(al,d3 .w) ,(a3)+
* X-coordinate
move.w
(a2,d3.w), (a3) +
* Y-coordinate
dbra
d4,paint3
* until all points in ptsin arra;
239
ST 3D Graphics
Abacus Software
move.w
#9,contrl
*
then call the
move.w
#0,contrl+6
*
function Filled
move. w
grhandle,contrl+12
*
Area
movem.1
d0-d2/a0-a2,- (a7)
jsr
vdi
movem.1
U7)+,d0-d2/a0-a2
add. 1
#8, dl
*
work on next
dbra
d7,paintl
*
surface in plad.
rts
* VDI clipping, used only with VDI functions, also for *
* filling surfaces. *
setclip:
move.w
#129,contrl
move. w
#2,contrl+2
move.w
#1,contrl+6
move.w
grhandle,contrl+12
move.w
#1,intin
move. w
clipxule,ptsin
move . w
clipyule,ptsin+2
move. w
clipxlri,ptsin+4
move.w
clipylri,ptsin+6
jsr
vdi
rts
. even
* Start of variable area *
* *
* Data area for rotation body *
.bss
240
Abacus Software
ST 3D Graphics
numro:
numpt:
rotxdat:
rotydat:
rotzdat:
rotdatx:
rotdaty:
rotdatz:
rlnumline:
rlnummark:
rlnumsurf:
plusagle:
rldatx:
rldaty:
rldatz:
rllin:
rlplane:
rlxdat:
rlydat:
rlzdat:
rlnumpt:
rlnumro:
.ds.w 1
.ds.w 1
. ds . 1 1
.ds.l 1
.ds.l 1
.ds.l 1
.ds.1 1
.ds.l 1
.ds.w 1
.ds.w 1
.ds.w 1
.ds.w 1
.ds.w 1540
.ds.w 1540
.ds.w 1540
•ds.l 3200 * 4-Bytes for every line
.ds.l 6600
.data
.dc.w 0,40,50,50,20,30,20,30,70,80,80,0
.dc.w 100,100, 80 ,60,40,30,30,-70,-80,-90,-100,-100
.dc.w 0 , 0 , 0 , 0 , 0 , 0,0,0,0, 0,0, 0
.dc.w 12
.dc.w 8 * Number of rotations for creation
241
ST 3D Graphics
Abacus Software
* *
* *
* Definition of the house *
* *
• data
housdatx:
.dc.w
-30,30,30,-30,30,-30,-30,30,0,0,-10,-10,10,10
. dc. w
30,30,30,30,30,30,30,30,30,30,30,30
housdaty:
. dc. w
30,30,-30,-30,30,30,-30,-30,70,70,-30,0,0,-30
. dc. w
20,20,0,0,20,20,0,0
.dc. w
-10,-10,-30,-30
housdatz:
.dc .w
60,60, 60, 60,-60,-60,-60,-60, 60,-60, 60,60, 60, 60
.dc.w
40,10,10,40,-10,-40,-40,-10
.dc. w
0,-20,-20,0
houslin:
.dc.w
1,2,2,3,3, 4,4,1,2,5, 5, 8,8, 3, 8,7, 7, 6, 6, 5, 6,1,7, 4
.dc.w
9,10,1,9,9,2,5,10,6,10,11,12,12,13,13,14
.dc.w
15,16, 16, 17,17,18; 18, 15,19,20,20,21,21,22,22, 19
.dc.w
23,24,24,25,25,26,26,23
* here are the definitions of the surfaces for the House *
* *
houspla:
.dc.
w
4,
1 ,2,2,3,3,4,4,
1,4,2,5,5,8,
8,3,
3,2
.dc.
w
4,
5,6, 6,7,7,8,8,
5, 4,7, 6, 6,1,
1*4,
4,7
.dc.
w
4,
4,3,3,8,8,7,7,
4,4,2, 9, 9,10
, 10,
5,5,
2
.dc.
w
4,
10,9,9,1,1,6,6
,10,3,1, 9, 9,
2 ,2,
1
.dc.
w
3,
5,10,10,6,6,5,
4,11,12,12,13,13
*14,
14,11
.dc.
w
4,
15,16,16,17,17
,18,18,15,4,
19,2
0,20
,21,21,22,22,19
-dc.
w
4,
23,24,24,25,25
,26,26,23
hnuinmark:
.dc.
w
26
* Number
of corner points
in
the house
hnumline:
. dc.
w
32
* Number
of lines in
the
house
hnumsurf:
.dc
:. w
13 * Number
of surfaces
in the house
242
Abacus Software
ST 3D Graphics
hxangle:
.dc.w
0
★
Rotation angle of house about X-axis
hyangle:
. dc. w
0
★
" ” " Y-axis
hzangle:
.dc.w
0
*
■' " " Z-axis
xwplus:
.dc.w
0
★
Angle increment about X-axis
ywplus:
• dc.w
0
★
Angle increment about Y-axis
zwplus:
• dc.w
0
★
Angle increment about Z-axis
picturex:
.dc.w
0
*
Definition of zero point of display
picturey:
.dc.w
0
*
entered by getreso
rotdpx:
.dc.w
0
rotdpy:
.dc.w
0
rotdpz:
.dc.w
0
rlzl:
.dc.w
0
normz:
.dc.w
1
.bss
plusrot:
.ds.l
1
first:
• ds .w
1
second:
.ds. w
1
deltal:
.ds. w
1
worldpla:
.ds.l
1
.data
plag:
.dc .b
1
. even
.bss
diffz:
.ds. w
1
243
ST 3D Graphics
Abacus Software
dx:
. ds. w
1
dy:
. ds. w
1
dz:
. ds. w
1
wrldx:
.ds .w
1600
* World coordinate array
wrldy:
.ds. w
1600
wrldz:
• ds. w
1600
viewx:
.ds. w
1600
* View coordinate array
viewy:
• ds. w
1600
viewz:
. ds. w
1600
screenx:
.ds .w
1600
* Screen coordinate array
screeny:
.ds. w
1600
wlinxy:
-ds. 1
3200
* Line array
wplane:
• ds. 1
6600
* Surface array
vplane:
-ds. 1
6600
* Surface array of visible surfaces
platz:
.ds. 1
2
pladress:
• ds.l
3000
* Surface array
surfcount:
.ds .w
1
numsurf:
. ds. w
1
zcount:
.ds.l
1
* Sum of all Z-coord.
zsurf:
• ds. w
1
* Individual Z-coord.of surface
sx:
-ds. w
1
sy:
.ds. w
1
sz :
.ds .w
1
px:
-ds. w
1
py:
• ds. w
1
pz:
.ds. w
1
244
Abacus Software
ST 3D Graphics
rx:
.ds. w
1
ry:
. ds. w
1
rz:
. ds. w
1
qx:
.ds. w
1
qy:
.ds. w
1
qz:
.ds.w
1
kx:
. ds. w
1
ky:
• ds.w
1
kz:
• ds.w
1
. data
prox:
.dc.w
0
* Coordinates of projection
proy:
.dc. w
0
* center, on the positive
proz:
• dc.w
1500
* Z-axis
.data
of f x:
.dc.w
0
* Transformation through rotation
of fy:
• dc.w
0
* to point [offx,offy,offz]
of fz:
.dc.w
0
xoffs:
.dc.w
0
* Inverse transformation to point
yoffs:
.dc.w
0
* [xoff,yoffs,zoffs]
zoffs:
.dc.w
0
.bss
loopc:
.ds. 1
. end
1
245
ST 3D Graphics
Abacus Software
4.4.1 New things in the main program rotatel.s:
The creation of a surface array during construction of the rotation body is
accomplished through the subroutine rotsurf:. The array (rlplane)
is of course passed from the subroutine makewrld: into the world
system (wplane). Furthermore, the subroutines hideit:, setclip:
and paintit: as well as the sort routine sort it: are new and have
already been explained. This sort routine sorts the array surfaddr,
which contains the Z-coordinates of the visible surfaces as well as the
addresses of the visible surfaces, according to increasing Z-coordinates.
The subroutine sort it: uses the old trick, an additional array index at
the beginning of the array. You can recognize this by the variable
space: in the variable part of the program. The variable space:
reserves additional space for a data record in the surfaddr-arrays. The
additional space is used as a marker during sorting. The actual sort
algorithm is nothing but a simple insert sort. For better understanding,
here is a structogram of the sort algorithm:
Figure 4.4.4: Structogram of the sort algorithm
246
Abacus Software
ST 3D Graphics
4.4.2 Sort algorithm:
In this program too, you should change various parameters to see what
they do. Up to now you had to change all the parameters in the program
text. This meant that you had to do a lot of assembling and linking just to
change a few parameters. The sort algorithm will allow you to change
parameters while the program is running. One method to change these
parameters is through a menu. See the diagram below. More about this in
the next section.
ST 3D Graphics
Abacus Software
4.5 Entering rotation lines with the mouse
We are now ready to combine the subroutines which we have so far used
separately and to construct a little program for creating rotation bodies,
including the removal of hidden lines and shading surfaces. Furthermore,
we also want to be able to enter the creation lines for the rotation body
with the mouse so that we don’t have to reassemble the program when we
want to use a new definition line. Owners of 520ST’s may find
themselves running short of memory. The available storage space permits
the input of 25 points for a definition line of the rotation body which can
then be rotated 60 times about the Y-axis. Thus a maximum of
25*61 = 1525 points and about 3000 lines and almost 1500 surfaces will
be created. To store this many parameters as well as the program we need
about 190Kbytes of memory, about a third of which is wasted because the
object is defined twice (datx, daty, datz, wrldx, wrldy,
wrldz). This is done to make things easier, but also in consideration of
the next main program which displays several objects at the same time.
We also have to keep in mind the memory require by the two screen
pages-about 64K
The amount of memory reserved in this program is intended for use on
the "smaller" model. Owners of 1 mega byte computers can display larger
objects if they want by reserving more space for the individual arrays.
The following relationships as are used to calculate the memory
requirements:
Number of points:= rlnumpt * (rlnumo+1)
Number of lines:= ( (rlnumpt-1) *rlnumro) +
(r1numpt * r1nuraro)
Number of surfaces:= (rlnumpt-1) * rlnumro
The number of lines can be estimated by multiplying the number of
points by two. Each point naturally requires two bytes of storage space.
You must also remember that every surface of the rotation body, requires
18 bytes of storage space since it is always constructed of four lines. In
the surfaddr array every surface requires 8 bytes of additional storage
space. With this information you can expand the programs yourself if you
have a 1040ST. The introduction of the operating system in ROM will
ease the lack of storage space. About 200K of RAM will be released by
248
Abacus Software
ST 3D Graphics
using the ROM. If you want to generate rotation bodies with more points
without RAM enhancement, whether through ROMs or RAM chips, you
can change the program so that the rotation body is not duplicated in the
arrays rldatx, rldaty, rldatz, but generated only in the world
system wrldx, wrldy, wrldz and the definition of rldatx,
rldaty, rldatz is completely omitted. This will free about 50
Kbytes of storage which includes the savings from the line array
(rllin) and surface array (rlplane). This space can be distributed
over the world array and thus used to generate larger bodies. The product
of the number of points and the number of rotations plus one is limited.
You can for example, rotate 16 points 90 times, or 40 points 30 times, etc.
The only limits placed are those of your imagination. The number of
rotation points to be entered is determined by the variable maxpoint and
can be changed there.
The use of this program differs in a few points from the programs
presented thus far. After the program start, a menu appears where you can
determine the desired number of rotations of a rotation line already
defined in the program. After you press one of the function keys F2 to F8,
the familiar chess figure appears in the ’’wire model mode" with the
desired number of rotations. The actual rotation parameters such as
position of the rotation point and rotation angle increments can be
changed with the cursor-keys. To remove hidden lines in this rotation
body press the H key on the keyboard (H for Hide). After the visible
surfaces have been drawn, you can fill them with a pattern by pressing the
P key (P for Paint). In both cases you can obtain a hardcopy by pressing
the <Altemate> and <Help> keys at the same time since the surfaces are
drawn and in the visible screen page (physical display ). The picture
drawn on the display remains until the <Retum> key is pressed and
cannot be changed. As a further option you can fill all the surfaces in the
"wire model mode" (P key), not only the visible ones. For hardcopy of a
wire model, press Shift D. By pressing the F10 key you return to the main
menu and you can enter a new rotation line with FI and the help of the
mouse.
After pressing FI a small crosshair and a cartesian coordinate system
whose origin is the. middle of the screen appear. By clicking the left
mouse button you can enter up to 25 points for a definition line. The right
mouse button ends the definition after which you must press a key to
return to the menu. You can set the number of rotations with the function
keys. We almost forgot to mention the significance of the F9 function key
which displays a mouse pointer when pressed in the wire model mode
249
ST 3D Graphics
Abacus Software
and allows you to set a new coordinate origin on the screen (left mouse
button). Here are some examples of definition lines and the rotation
bodies which result.
Abacus Software
ST 3D Graphics
ST 3D Graphics
Abacus Software
252
Abacus Software
ST 3D Graphics
ST 3D Graphics
Abacus Software
Abacus Software
ST 3D Graphics
ST 3D Graphics
Abacus Software
Figure 4.5.13
Don’t let the program listing frighten you. First of all, if you have entered
the previous programs, all you have to do is enter the new subroutines
and change the main loop a bit. Second, you can get a disk containing all
of the programs in the book from Abacus Software or your dealer.
253882 bytes used 1
K PRINTERS
N TUTORIAL
C FRY
CONV TTP
HL10 PRO
OUTPUT PRG
SPLIT TTP
STANDARD PRT
TEXTPRO PRG
TUTORIAL TXT
XTTUTORI TOC
l
1442236 bytes used in 123 itens.
BASIC
PRG
138344
11-2
BASIC
RSC
4648
11-2
BASIC
URK
346
11-2
BASIC1
BAR
14801
11-2
□
OPEN APPLICATION
Nane: BATCH .TTP
Parameters: .
aslink grlinkl nenul|_
1
333356 butes used in
H0USE1
PRG
H0USE1
S
MAINi
PR6
HAIN1
HAIN1C0
S
PRG
MAIN1CD
S
MENU1
PRG
MENU1
S
HULTI1
PRG
_
HULTI1
S
PAINT1
PRG
■
PAIKT1
R0TATE1
S
PRG
1
R0TATE1
S
■
Abacus Software
ST 3D Graphics
***********************************************************************
* menul.s 2/18/1986 *
* Creation of rotation bodies Uwe Braun 1985 Version 2.2 *
* with hidden line algorithm and painting *
* *
.globl main,xoffs,yoffs,zoffs,offx,offy,offz
•globl viewx,viewy,viewz
.globl wlinxy,mouse_off,setrotdp,inp_chan,pointrot
. text
main:
mainl:
mainlopl:
jsr
apinit
* Announce programm
jsr
grafhand
* Get screen handler
jsr
openwork
* Display
jsr
mouse off
* Turn off mouse
jsr
getreso
* Display resolution
jsr
setcocli
* set Cohen Sutherland clip.
jsr
clearbuf
jsr
menu
jsr
makerotl
* create rotation body
jsr
makewrld
* create world system
jsr
wrld2set
* pass world parameters
jsr
pageup
jsr
clwork
jsr
setrotdp
* initialize observer ref. point
jsr
pagedown
* Display logical screen page
jsr
clwork
jsr
inp_chan
jsr
pointrot
* rotate around observ. ref. point
jsr
pers
* Perspective transformation
jsr
drawnl
jsr
pageup
* Display physical screen page
jsr
testhide
257
ST 3D Graphics
Abacus Software
jsr
inp chan *
Input new parameters
jsr
clwork *
clear page not displayed
jsr
pointrot *
Rotate around rot ref
. point
jsr
pers *
Transform new points
jsr
drawnl
jsr
pagedown *
Display this logical
page
jsr
inp chan *
Input and change parameters
jsr
clwork *
erase physical page
jmp
mainlopl *
to main loop
move.1
physbase,logbase
jsr
pageup *
switch to normal screen page
rts
*
back to link file and
end
* Display menu and selection of menu points
menu:
jsr
switch
* Display and draw the same
move.1
#text2,a0
* screen page
jsr
printf
* Display menu list
move.1
#text3,aO
jsr
printf
menuO:
jsr
inkey
* Read keyboard
swap
dO
cmp.b
#$3b,dO
* Fl key pressed ?
bne
menul
jsr
inpmous
* if yes, enter a line
bra
menu
menul:
cmp .b
#$3c,d0
* F2 key pressed ?
bne
menu 2
move.w
#4, rlnumro
* if yes, then initial number of
bra
menend
* rotations to four
258
Abacus Software
ST 3D Graphics
menu2:
cmp.b
#$3d,d0 * F3 key
bne
menu 3
move.w
#8,rlnumro
bra
menend
menu3:
cmp.b
#$3e,d0 * F4 key
bne
menu 4
move.w
#12,rlnumro
bra
menend
menu*?:
cmp.b
#$3f,dO * F5 key
bne
menu 5
move.w
#18, rlnumro
bra
menend
menu5:
cmp.b
#$40,dO * F6 key
bne
menu6
move. w
#24,rlnumro
bra
menend
menu6:
cmp.b
#$41,dO * F7 key
bne
menu7
move. w
#45,rlnumro
bra
menend
menu7:
cmp.b
#$42,dO * F8 key
bne
menu 8
move.w
#60,rlnumro
bra
menend
menu8 :
* Room for
menu9:
cmp. b
#$44,dO * F10 key
bne
menuO
addq.1
#4,a7
bra
ma inend
menend:
rts
additional
keyboard commands
259
ST 3D Graphics
Abacus Software
*****************************************************************
* Test if removal of hidden surface and shading of surfaces *
* is desired *
*****************************************************************
jsr
inkey
*
Read keyboard
swap
dO
cmp.b
#$23,dO
★
h key pressed ?
beq
dohide
*
if yes, call hideit
cmp .b
#$19,dO
*
p key pressed ?
beq
dopaint
*
is yes, shade
rts
★
if not, return
★A*****************************************************************
* Call hideit routine to remove hidden Surfaces *
*******************************************************************
dohide:
jsr
switch
jsr
clwork
jsr
hideit
jsr
surfdraw
dohidel:
jsr
inkey
swap
dO
cmp.b
#$19,dO
beq
dopain2
cmp.b
#$lc,d0
bne
dohidel
jsr
rts
pageup
dopain2:
jsr
paintit
dopain3:
jsr
inkey
swap
dO
cmp.b
#$lc,dO
bne
dopain3
jsr
rts
pageup
* or you won't see anything
* erase display
* remove
* and draw
* shade too ?
* if yes, call fill routine
* if not, wait for activation of
* Return key on main keyboard
* and back
* Shade surfaces
* wait for return key
260
Abacus Software
ST 3D Graphics
***********************************************************************
* Shade all surfaces defined in the world system
**************,********************************************************
dopaint:
jsr
switch
jsr
clwork
jsr
paintall
* shade all
dopaintl:
jsr
inkey
swap
dO
cmp. b
#$lc,dO
* and wait for Return key on the
bne
dopaintl
* main keyboard
jsr
pageup
rts
* Create the rotation body
makerot1: jsr
jsr
rts
r lset * Set parameters of this rot. body
rotstart * Create rot. body
* Input and change parameters
inp chan:
jsr
inkey
cmp.b
#' D',dO
bne
inpwait
jsr
scrdmp
inpwait:
swap
dO
cmp.b
#$4d,d0
bne
inpl
addq.w
#1,ywplus
bra
inpendl
* Read keyboard, key code in
* Make hardcopy
* Test DO for
* Cursor-right
* if yes, add one to Y-angle
* and continue
261
ST 3D Graphics
Abacus Software
inpl:
cmp .b
#$4b,dO
bne
inp2
subq.w
#1,ywplus
bra
inpendl
inp2:
cmp .b
#$50,dO
bne
inp3
addq.w
#1, xwplus
bra
inpendl
inp3:
cmp .b
#$48,dO
bne
inp3a
subq.w
#1,xwplus
bra
inpendl
inp3a:
cmp.b
#$61,dO
bne
inp3b
subq.w
#1,zwplus
bra
inpendl
inp3b:
cmp.b
#$62,dO
bne
inp4
addq.w
#1,zwplus
bra
inpendl
inp4:
cmp.b
#$4e,dO
bne
inp5
sub. w
#25,dist
bra
inpendl
inp5:
cmp.b
#$4a,d0
bne
inp6
add. w
#25,dist
bra
inpendl
inp6:
cmp.b
#$66,dO
bne
inp7
sub.w
#15,rotdpz
bra
inpendl
* Cursor-left, if yes, subtract
* one from Y-angle increment
* Cursor-down, if yes
* add one to X-angle increment
* Cursor-up
* subtract one
* Undo key
* Help key
* plus key on the keypad
* if yes, subtract 25 from base of
* projection plane (Z-coordinate)
* minus key on the keypad
*
* if yes, add 25
* * key on keypad
* if yes, subtract 15 from rotation
* point Z-coordinate
* make changes
262
Abacus Software
ST 3D Graphics
inp7 :
cmp -b
#$65,dO
* Division key on keypad
bne
inp8
add. w
#15,rotdpz
* add 15
bra
inpendl
inp8:
cmp. b
#$43,dO
* F9 pressed ?, if yes,
bne
inplO
jsr
newmidd
* display new screen center
bra
inpendl
inplO:
cmp -b
#$44,dO
* F10 pressed ?
bne
inpendl
addq.1
#4,a7
* if yes, jump to new input
bra
mainl
inpendl:
move.w
hyangle,dl
* Rotation angle about the Y-axis
add.w
ywplus,dl
* add increment
cmp. w
#360,dl
* if larger than 360, subtract 360
bge
inpend2
cmp. w
#-360,dl
* if smaller than 360,
ble
inpend3
* add 360
bra
inpend4
inpend2:
sub. w
#360,dl
bra
inpend4
inpend3:
add. w
#360,dl
inpendl:
move.w
dl,hyangle
move.w
hxangle,dl
* proceed in the same manner with
add. w
xwplus,dl
* rotation angle about the X-axis
cmp. w
#360,dl
bge
inpend5
cmp. w
#-360,dl
ble
inpend6
bra
inpend7
inpend5:
sub. w
#360,dl
bra
inpend7
inpend6:
add.w
#360,dl
inpend7:
move . w
dl,hxangle
★
263
ST 3D Graphics
Abacus Software
move.w
hzangle,dl
add. w
zwplus,dl
cmp. w
#360,dl
bge
inpend8
cmp. w
#-360,dl
ble
inpend9
bra
inpendlO
inpend8:
sub. w
#360,dl
bra
inpendlO
inpend9:
add. w
#360,dl
inpendlO:
move.w
rt s
dl,hzangle
fr*****************************************************************
* Set the location of the coordinate origin of the screen *
* system with the mouse *
******************************************************************
newmidd:
jsr
switch
jsr
mousform
★
change mouse form
newmiddl:
move. w
x0,d2
move. w
y0,d3
jsr
mouspos
*
wait for mouse input
move. w
x0,d2
★
must be called for unknown reasons
move. w
y0,d3
★
twice for one input of the
jsr
mouspos
*
Position
cmp.b
#$20,dl
*
left button ? if not, then
bne
newmiddl
★
once more from the beginning
move. w
a
rv>
*•
X
o
*
store new coordinates
move.w
d3,y0
rts
********************************************************************
* Determine the current screen resolution *
********■*********★**********★**************"****'****•***'*■*******■****
getreso: move.w #4,-(a7)
trap #14
addq.l #2,a7
264
Abacus Software
ST 3D Graphics
cmp.w
#2, dO
bne
getrl
move.w
#320, picturex
* Monochrome monitor
move. w
#200,picturey
bra
getrend
getrl:
cmp. w
#1, d0
bne
getr2
move.w
#320,picturex
* medium resolution (640*200
move. w
#100,picturey
bra
getrend
getr2:
move. w
#160,picturex
* low resolution (320*200)
move. w
#100,picturey
getrend:
rts
* Hardcopy of screen, called by inp_chan
scrdmp: move.w #20,-(al)
trap #14
addq.l #2,a7
jsr clearbuf
rts
* Initialize the rotation reference point to [0,0,0] *
move . w
#0,dl
* set the initial rotation
move.w
dl, rotdpx
* ref. point
move.w
dl, rotdpy
move. w
dl,rotdpz
move.w
#0,hyangle
* initial rotation angle
move.w
#0,hzangle
move.w
#0,hxangle
move. w
#0,ywplus
move. w
#0,xwplus
move -w
rts
#0,zwplus
265
ST 3D Graphics
Abacus Software
* Rotation around the rot. ref. point about all three axes *
move.w
hxangle,xangle
★
rotate the world around the
move. w
hyangle,yangle
move. w
hzangle,zangle
move.w
rotdpx,dO
★
rotation ref. point
move.w
rotdpy,dl
move.w
rotdpz,d2
move. w
dO,xoffs
*
add for inverse transformation
move.w
dl,yoffs
move.w
d2,zoffs
neg. w
dO
neg. w
dl
neg.w
d2
move.w
dO,offx
*
subtract for tranformation
move.w
dl,offy
move. w
d2,offz
jsr
matinit
★
initialize matrix
jsr
zrotate
★
rotate 'matrix' about Z-axis
jsr
yrotate
*
rotate 'matrix' about Y-axis
jsr
xrotate
*
then rotate about X-axis
jsr
rotate
A
multiply point with matrix
rts
*********************************************************************
* Set the limit of display window for the Cohen-Sutherland clip *
* algorithm built into the draw-line algorithm *
* The limits are freely selectable by the user which makes the *
* draw-line algorithm very flexible. *
*********************************************************************
move. w
#0,clipxule
move.w
#0,clipyule
move. w
picturex,dl
Isl. w
#1, dl
*
times two
subq.w
#1, dl
■k
minus one equals
move. w
dl,clipxlri
*
639 for monochrome
move.w
picturey,dl
lsl. w
#l,dl
★
times two minus one equals
subq.w
#1, dl
*
399 for monochrome
266
Abacus Software
ST 3D Graphics
move.w dl,clipylri
rt s
* Transfer object data into the world system .
makewrld:
move.1
trldatx,al
move. 1
trldaty,a2
move.1
#rldatz,a3
move. 1
#wrldx,a4
move. 1
#wrldy,a5
move . 1
#wrldz,a6
move. w
rlnummark,dO
ext. 1
dO
subq. 1
#l,dO
makewll:
move.w
(al) +, <a4) +
move.w
(a2) +, (a5) +
move.w
(a3)+,(a6)+
dbra
dO,makewll
move.w
rlnumline,dO
ext. 1
dO
subq.1
#1, dO
move.1
#rllin,al
move. 1
twlinxy,a2
makewl2:
move. 1
(al) +, (a2) +
dbra
d0,makewl2
move.1
worldpla,aO
move.1
#wplane,al
move.w
rlnumsurf,dO
ext. 1
dO
subq.1
#1, dO
makewld:
move. w
(aO) +,dl
move. w
dl, (al) +
ext. 1
dl
subq. 1
#1, dl
makewl4:
move . 1
(aO)+,(al)+
dbra
dl, makew!4
* create the world system through
* copying the point coordinates
* into the world system
* Number of lines
* Copy lines into world Line
* array
* Adress of surface definition
* of the body,
* Number of surfaces on the body
* as counter
* All lines in this surface,
* and of course the number of
* surfaces copied to world surface
* array
* copy every line of this surface
* to the world array
267
ST 3D Graphics
Abacus Software
wrldset:
dbra
d0,makewl3 *
until all surfaces are
completed
rts
move. 1
#wrldx,datx *
Pass variables for
move.1
#wrldy,daty *
the rotation routine
move.1
#wrldz,datz
move.1
#viewx, pointx
move.1
#viewy,pointy
move -1
fviewz,pointz
move.1
Iwlinxy,linxy
move.w
picturex,xO *
Coordinate source for
the
move.w
picturey,yO *
screen system
move.w
proz,zobs *
projection center
move.w
rlzl,dist *
position of projection
plane
move.1
tscreenx,xplot
move.1
iscreeny,yplot
move, w
hnumline,numline
move, w
hnummark,nummark
move.w
hnumsurf,numsurf
rts
268
Abacus Software
ST 3D Graphics
*********************************************************************
* Enter visible surface into the vplane array
*********************************************************************
hideit:
visible:
move . w
numsurf, dO
*
Number of surfaces as counter
ext. 1
dO
subq.1
#1* dO
move.1
#viewx,al
*
point coordinates stored here
move . 1
#viewy,a2
move.1
ffviewz, a3
move.1
#wplane,aO
★
here is information for every
move. 1
#vplane,a5
★
surface
move.w
#0,surfcount
*
counts the known visible surfaces
move.1
#pladress,a6
*
Address of the surface storage
move.w
(aO),dl
★
start with first surface, number
ext. 1
dl
*
of points in this surface in Dl
move.w
2(aO),d2
*
Offset of first point of this surface
move.w
4(aO),.d3
*
Offset of second point
move. w
8(aO),d4
★
Offset of third point
subq.w
#1, d2
*
Subtract one from current point offset
subq. w
#1, d3
★
for access to point srray
subq.w
#l,d4
lsl. w
#lf d2
★
then multiply by two
lsl. w
#l,d3
lsl. w
#l,d4
*
and finally access the current
move. w
(al,d3.w),d6
*
point coordinates
cmp. w
(al,d4.w),d6
★
comparison recognizes two points
bne
doitl
★
with some coordinates which can occur
move. w
(a2,d3.w) ,d6
★
during construction of rotation
cmp. w
(a2,d4.w),d6
*
bodies. If two
bne
doitl
★
points where all point coordinates
move.w
(a3,d4.w),d6
★
(x,y,z) match, the program selects
cmp.w
<a3,d3.w),d6
*
a third point to determine the two
bne
doitl
★
vectors
move . w
12 (aO) , d4
subq.w
#l,d4
lsl. w
#1, d4
269
ST 3D Graphics
Abacus Software
doit1:
*
★
move.w
(al,d3.w) ,d5
* here the two vectors which lie in
move.w
d5, kx
* surface plane are detemined by
* subtraction
sub. w
(al, d2.w),d5
* of coordinates from two points of
move.w
d5, px
* points in this surface
move.w
(a2,d3.w),d5
move.w
d5, ky
* the direction coordinates of the
sub. w
(a2,d2.w),d5
* vector are stored in the variable;
move.w
d5,py
* qx,qy,qz and px,py,pz
move. w
(a3, d3 . w) , d5
move.w
d5, kz
sub. w
(a3,d2.w),d5
move.w
d5,pz
move.w
(al,d4.w),d5
* calculation of vector Q
sub. w
<al,d2.w),d5
move.w
(a2,d4.w),d6
sub. w
(a2,d2.w),d6
move. w
{a3, d4.w),d7
sub. w
(a3, d2.w),d7
move. w
d5, dl
* qx
move.w
d6,d2
* qy
move. w
d7,d3
* qz
mu Is
py,d3
* calculation of the cross product
mu Is
pZ/ d2
* of the vector perpendicular to
* the surface
sub.w
d2,d3
move.w
d3, rx
muls
pz, dl
mu Is
px, d7
sub. w
d7, dl
* the direction coordinates of
* the vector
move.w
dl, ry
* which is perpendicular to the
muls
px, d6
* surface area stored temporarily
muls
py,d5
* rx,ry,rz
sub. w
d5,d6
move.w
d6, rz
move.w
prox,dl
* The projection center is used as
sub.w
kx, dl
* the comparison point for the
270
Abacus Software
ST 3D Graphics
move.w
proy,d2
★
visibility of a surface, which is
sub. w
Jcy,d2
★
adequate for this viewing
move. w
proz,d3
*
situation. One can also use
sub.w
kz, d3
*
the observation ref. point
mu Is
rx, dl
*
as the comparison point.
mu Is
ry,d2
*
Now follows the comparison of the
muls
rz, d3
*
vector R and the vector from
add. 1
dl, d2
*
one point on the surface to the
add. 1
d2,d3
*
projection center by creating the
bmi
dosight
★
scalar product of the two vectors
* the surface is visible, otherwise continue with next surface.
move.w (aO),dl * Number of lines in surface
ext.1 dl
lsl.l #2,dl * Number of lines times 4 = space for lines
addq.l #2,dl * plus 2 bytes for the number of lines
add.1 dl,aO * add to surface array, for access to
sight1: dbra dO,visible * next surface. If all surfaces
bra hideend * completed, go to end.
dosight: move.w <aO),dl * Number of lines in this surface
ext.l dl * multiplied by two gives result of
move.l dl,d2
lsl.l #l,dl * number of words to be transmitted
move.l a0,a4
addq.l #2,a4 * Access to first line of surface
move.w #0,zsurf * Erase addition storage
(a4)+,d6 * first line of surface
d6 * first point in lower half of DO
#l,d6 * adapt Index
#1,d6 * adapt Operand size (2-byte)
move.w (a3,d6.w),d6 * Z-coordinate of this point
add.w d6,zsurf * add all Z-Coordinates
dbra d2,sight2 * until all lines have been processed
sight2: move.l
swap
subq.w
lsl. w
271
ST 3D Graphics
Abacus Software
move. w
zsurf,d6
★
ext. 1
d6
*
lsr. 1
#2,d6
*
ext .1
d6
*
move. 1
d6, (a6) +
*
move.1
aO, <a6)+
*
sight3:
move.w
(aO)+, (a5) +
*
dbra
dl,sight3
*
addq. w
#1,surfcount
*
bra
sight1
*
hideend:
rts
Divide sum of all Z-coordinates of
this surface by the number of lines in
the surface. Surfaces created by
rotation always have four lines
store middle Z-coordinates
followed by address of surface
transmit the number of lines
and the individual lines
add one to the number of surfaces
and work on next one
* Draw all surfaces contained in vplane *
surfdraw:
*
Draws the number of surfaces passed
move.1
xplot,a4
★
in surfcount whose descriptions
move.1
yplot,a5
move.1
#vplane,a 6
★
were entered by hideit in the array
move.w
surfcount,dO
*
at address vplane
ext. 1
dO
subq.1
#l,dO
★
if there are no surfaces in the arr.
bmi
surfend
*
then end.
surflopl:
move.w
(a6) +,dl
*
Number of lines in this surface
ext. 1
dl
*
as counter of lines to be drawn.
subq.1
#1, dl
surflop2:
move.1
(a6)+,d5
★
first line of this surface
subq.w
#1, d5
★
Access to screen array where
lsl. w
#1, d5
★
screen coordinates of points are.
move. w
0 (a4,d5.w),d2
move . w
0 (a5,d5.w),d3
★
extract points
swap
d5
*
pass routine.
272
Abacus Software
ST 3D Graphics
subq. w
#1, d5
lsl. w
#1, d5
move.w
0 <a4, d5 . w) , a2
move.w
0(a5,d5.w),a3
jsr
drawl
dbra
dl,surflop2
dbra
dO,surflopl
surfend: rts
* second point belonging to
* line
* draw line, until all lines in this
* surface are drawn and repeat
* until all surfaces are drawn.
* finally return.
* Set parameters of this rotation body *
rlset:
move. 1
#rlxdat,rotxdat
move. 1
#rlydat,rotydat
move. 1
frlzdat,rotzdat
move.1
#rldatx,rotdatx
move.1
#rldaty,rotdaty
move.1
#rldatz,rotdatz
move . 1
rotdatx,datx
move.1
rotdaty,daty
move. 1
rotdatz,datz
move.w
rlnumro,numro
move.w
rlnumpt,numpt
move.1
#rllin,linxy
move.1
rts
#rlplane,worldpla
* Pass parameters of this
* rotation body to routine
* for generating the
* rotation body
* Array addresses of points
* Number of desired rotatations.
* Number of points to be rotated
* Address of line array
* Address of surface array
**************
* and create rotation body
•k
★
*
rotstart: move.w
lsl. w
ext .1
move. 1
numpt,dO
#1, dO
dO
dO,plusrot
* Rotate the def line
* numro+1 times about the Y-axis
* Storage space for one line
273
ST 3D Graphics
Abacus Software
rloopl:
rotlin:
move.w
numpt,nummark
* Number of points
move.1
rotdatx,pointx
* rotate to here
move. 1
rotdaty,pointy
move. 1
rotdatz,pointz
move. w
#0, yangle
move.w
#360,dO
* 360 / numro = angle increment
divs
numro,dO
* per rotation
move.w
dO, plusagle
* store
move. w
numro,dO
* numro +1 times
ext. 1
dO
move.1
dO, loopc
* as loop counter
move.1
rotxdat,datx
move.1
rotydat,daty
move.1
rotzdat,datz
jsr
yrot
* rotate
move.1
pointx,dl
* add offset
add. 1
plusrot,dl
move.1
dl,pointx
move.1
pointy,dl
add. 1
plusrot,dl
move.1
dl,pointy
move. 1
pointz,dl
add. 1
plusrot,dl
move.1
dl,pointz
move. w
yangle,d7
add.w
plusagle,d7
move.w
d7,yangle
move.1
loopc,dO
dbra
dO,rloopl
move.w
rlnumro,numro
move.w
r1numpt,numpt
jsr
rotlin
* Create line array
jsr
rotsurf
* Create surface array
rts
move. w
#l,d7
move.w
numro,d4
* Number of rotations
ext. 1
d4
subq.1
#l,d4
274
Abacus Software
ST 3D Graphics
rotlopl:
rotlop2:
rotlop3:
rotlop4 :
move. w
numpt,dl
* Number of points in the def. line
subq.w
#1, dl
* both as counter
lsl. w
#2, dl
* times two
ext. 1
dl
move. 1
dl,plusrot
move. w
numpt,d5
* Number of points minus one
ext .1
d5
* repeat, last line
subq.1
#2, d5
* connects the points (n-l,n)
move.1
linxy,al
move. w
d7,d6
move.w
d6, <al) +
* the first line connects the
addq.w
#l,d6
* points (1,2) then (2,3) etc.
move.w
d6,(al)+
dbra
d5,rotlop2
move.1
linxy,dl
add. 1
plusrot,dl
move.1
dl,linxy
move.w
numpt,dO
add. w
d0,d7
dbra
d4,rotlopl
move. w
numpt,d7
move. w
d7,deltal
lsl. w
#2, d7
ext. 1
d7
move. 1
d7,plusrot
move. w
#1, d6
move . w
numpt,dO
ext. 1
dO
subq.1
#l,dO
move. w
numro,dl
ext. 1
dl
subq.1
#1, dl
move.w
d6,d5
move.w
d5, (al) +
* now generate the cross connections
add. w
deltal,d5
* which connect the individual lines
move.w
d5, (al) +
* created by rotation
dbra
dl,rotlop4
275
ST 3D Graphics
Abacus Software
rotsurf:
add. w
#l,d6
dbra
dO,rotlop3
move.w
numro,dl
add. w
#l,dl
mu Is
nummark,dl
move.w
dl,rlnummark
move.w
numpt,dl
mu Is
numro,dl
move.w
numpt,d2
subq.w
#1, d2
mu Is
numro,d2
add. w
dl, d2
move.w
rts
d2,rlnumline * Number of lines stored
move. w
numro,dO
*
create surfaces of
the
ext .1
dO
*
rotation body
subq.1
#l,dO
move. w
numpt,d7
*
Number of points minus one
ext .1
d7
*
repeat
subq.1
#2,d7
move.1
d7,plusrot
move.1
worldpla,aO
*
Address of surface
array
move.w
#1, dl
move.w
numpt,d2
*
Number of points
addq.w
#1, d2
276
Abacus Software
ST 3D Graphics
rotf11:
rotf12 :
move.l plusrot,d7 * Offset
move.w dl,d4
move.w d2,d5
addq.w #l,d4
addq.w #l,d5
move.w #4, (aO> + * Number of lines / surfaces
move.w dl,(aO)+ * the first surface is
move.w d4,(a0) + * created here
move. w d4, (aO) +
move.w d5, (aO) +
move . w d5, (aO) +
move . w d2, (aO) +
move . w d2, (aO) +
move . w dl, (aO) +
addq.w #l,dl
addq.w #l,d2
dbra d7,rotfl2
addq.w #l,dl
addq.w #l,d2
dbra dO,rotfll
move.w numpt,dl
subq.w #1, dl
muls numro,dl
move.w dl,rlnumsurf
rts
277
ST 3D Graphics
Abacus Software
************************************************************************
* Transfer the world parameters and the variables to the link file *
************************************************************************
wrld2set: move.1
move. 1
move.1
move.1
move.1
move.1
move.1
move.w
move.w
move.w
move.w
move.1
move.1
move.w
move.w
move -w
rts
#wrldx,datx *
#wrldy,daty *
#wrldz,datz *
#viewx,pointx
#viewy,pointy
Iviewz,pointz
#wlinxy,linxy
picturex,xO
picturey,yO
proz,zobs
rlzl,dist
#screenx, xplot
#screeny,yplot
rlnumline,numline
rlnummark,nummark
rlnumsurf,numsurf
transfer the world parameters
and the variables to the
routines in the link file
**********************************************************************
* Sort all surfaces entered in pladress *
sortit:
sortmain:
move.1
#pladress,aO
move.w
surfcount,d7
ext. 1
d7
•*
for i = 2
to n corresponds to
subq.1
#2, d7
*
number of
runs
bmi
serror
★
for i = 1
to n-1 because of
move.1
#1, dl
*
different
array structure
move.1
dl, d2
subq.1
#l,d2
★
j = i -1
move.1
dl, d3
*
i
lsl.l
#3,d3
move.1
(aO, d3.1),d5
*
Comparison value x = a[i]
move.1
4(a0,d3.1),d6
*
address of the surface
move.1
d5,space
*
a [0] = x
= a[-l] in this
move.1
d6,space+4
*
array
278
Abacus Software
ST 3D Graphics
sortlopl:
move.1
d2,d4
* j
lsl.l
#3, d4
* j times 8 for access to
array
cmp. 1
(a0,d4.1) ,d5
* Z-coordinate of surface
bge
sortwl
* while x < a[j] do
move.1
(a0,d4.1),8(a0,d4
.1) * a [ j + 1] = a [ j]
move.1
4(a0,d4.1),12(aO,
d4.1) * Address of surface array
subq.1
#1, d2
* j = j-1
bra
sortlopl
sortwl:
move. 1
d5,8(aO,d4.1)
* a[j+1] = x
move. 1
d6,12(a0,d4.1)
* Pass address also
addq. 1
#1/ dl
* i - i + 1
dbra
d7,sortmain
* Until all surfaces have
been sorted
sortend:
rts
serror:
rts
* On error simply return
********************************************************************
* paintall draws all surfaces in world array wplane independent of *
* their visibility; all surface addresses and middle Z-coordinates *
* are entered into the pladress array. *
********«**************+********************************************
paintall:
move.w numsurf,dO
ext.l dO
subq.l #l,dO
bmi pquit
* Number of surfaces
* if no surface present
* then terminate
move.1 #viewz,a3
move.l #wplane,aO
move.w #0,surfcount
move.l #pladress,a6
* Surface counter for surfdraw
* surfaces are entered here
svisible:
move.w (aO),dl * all surfaces are visible
ext.1 dl
subq.l #l,dl
move.w #0,zsurf * middle Z-coordinate
move.l a0,a4
addq.l #2,a4
279
ST 3D Graphics
Abacus Software
ssightbl: move.1
(a4) +,d2
* first line of surface
swap
d2
subq.w
#1» d2
lsl. w
#1/ d2
ddoit1:
move.w
(a3,d2.w),d6
* add all Z-coordinates of this
add. w
d6,zsurf
* surface
dbra
dl,ssightbl
move.w
zsurf,d6
ext. 1
d6
* then divide by four, shifting
lsr. 1
#2,d6
* is possible only with rotation
ext. 1
d6
* bodies since each surface has
move.1
d6, <a6)+
* exactly four lines otherwise divide
move.1
aO, (a6) +
* by number of lines
addq.w
#1,surfcount
* increment surface counter for surfdraw
move.w
(aO),dl
* AO still points to number of lines
ext. 1
dl
* in this surface
lsl.l
#2, dl
* Number of lines times four (1 long)
addq.1
#2, dl
* 2 bytes for the number of lines
add. 1
dl, aO
* AO points to next surface
dbra
dO, svisible
move.w
numsurf,surfcount
jsr
paintit
* Fill surfaces in pladress
pquit:
rt s
paintit:
jsr
setclip
* GEM clipping routine for filled area
jsr
sortit
* Sort surfaces according to Z-coordinates
move.w
#1, dO
* Write mode to replace
jsr
filmode
jsr
filform
* frame filled surface
jsr
filcolor
* Shading color is one
move. w
#2, dO
* Fill style
jsr
filstyle
move. 1
xplot,al
* Address of screen coordinates
move. 1
yplot,a2
move. w
surfcount, dl * Number of surface to be filled
ext .1
d7
* as counter
subq.1
#1, d?
* access last surface in array
move.1
dl , dO
* multiply by eight
280
Abacus Software
ST 3D Graphics
lsl.l
move. 1
move. 1
move.1
move.1
neg. 1
add. 1
paintl: move.1
move.1
add. 1
lsl.l
divs
neg.w
add. w
bpl
move.w
paint2: move.w
jsr
move.1
move.1
move.w
addq.w
move.w
move.1
swap
subq.w
lsl. w
move.w
move.w
swap
sub. w
lsl. w
move.w
move.w
subq.w
ext .1
paint3: move.1
subq.w
lsl. w
move.w
move.w
#3, dO
tpladress,aO
(aO, dO . 1) , d5
#0, dl
(aO,dl.1), d6
d6
d6,d5
d5,d0
(aO,dl.l),d2
d6,d2
#3,d2
dO, d2
d2
#6,d2
paint2
#1, d2
d2, dO
filindex
#ptsin,a3
4 (aO, dl. 1) ,a6
(a6)+,d4
#1»<34
d4,contrl+2
(a6) + ,d3
d3
#l,d3
#l,d3
<al,d3.w>,(a3)+
(a2,d3.w) ,(a3) +
d3
#1» d3
#l»d3
(al,d3.w),(a3)+
(a2, d3 . w) , (a3) +
#3, d4
d4
(a6)+,d3
#1< d3
#l,d3
(al, d3 .w), (a3) +
(a2, d3 . w), (a3) +
* here are largest Z-coordinate
* surfaces
* first surface in array
* smallest Z-coordinate
* subtract from one another
* first surface in array
* plus smallest Z-coordinate
* times eight, eight different
* shading patterns, divide by
* difference leave out last
* pattern.
* set fill index
* enter points here
* Address of surface
* Number of lines
* first point counted twice
* first line of surface
* transfer to ptsin array
* pass Y-coordinate
* transmit next point
* transmit Y-coordinate
* already two points transmitted
* and one because of dbra
* next line
* X-coordinate
* Y-coordinate
281
ST 3D Graphics
Abacus Software
dbra
d4,paint3
* until all
points in Ptsin-Array
move.w
#9,contrl
* then call
the fill area
function
move. w
#0,contrl+6
move.w
grhandle,contrl+12
movem.1
dO-d2/aO-a2,-(a7)
jsr
vdi
movem.1
(a7)+,d0-d2/a0-a2
add. 1
#8, dl
* work on next surface in
pladress
dbra
d7,paintl
rts
* VDI clipping, only needed when VDI functions are used, *
* for surface filling.
setclip:
move.w
#129,contrl
move.w
#2,contrl+2
move.w
#1,contrl+6
move.w
grhandle,contrl+12
move.w
#1,intin
move.w
clipxule,ptsin
move.w
clipyule,ptsin+2
move.w
clipxlri,ptsin+4
move. w
clipylri,ptsin+6
jsr
vdi
rts
*******************************************************************
* this subroutine allows coordinates to entered with the Mouse
* The maximum number of points is in the variable maxpoint, and
* is limited only by storage space
*******************************************************************
inpmous:
jsr
switch
move. w
#5, dO
jsr
setform
move.w
#1, dO
* set input mode
to mouse-reguest
move.w
#1, dl
* wait for mouse
input which is
jsr
setmode
* terminated by
key activation and
282
Abacus Software
ST 3D Graphics
mouslopl:
mousl:
mouslop2:
jsr
coord * mouse clicking
move. 1
#0,adressx
move.w
#5,d0 * set polymarker to diagonal cross
jsr
marktype
jsr
mouspos
*
For unknown reasons function must
move. w
picturex,d2
*
be called twice to work once.
add. w
#15,d2
move.w
picturey,d3
sub.w
#40,d3
jsr
mouspos
cmp .b
#$20,dl
*
wait until the left mouse button is
bne
mouslopl
*
pressed
move.1
#rlxdat,a4
*
arrays in which input
move.1
#rlydat,a5
*
coordinates are entered; enough
move.1
#rlzdat,a6
*
storage must have been reserved
move.w
d2,newx
*
store mouse X and Y positions
move.w
d3,newy
jsr
saveit
*
and pass line array
move.w
newx,d2
move.w
newy,d3
jsr
markit
*
set a polymarker
add. 1
#1,adressx
*
increment counter
nop
move.w
newx,altx
move.w
newy,alty
move.w
altx,d2
*
pass old position of the mouse
move. w
alty,d3
jsr
mouspos
*
and call again
jsr
mouspos
cmp .b
#$21,dl
*
if right mouse button, then
beq
mousend
*
end of mouse input
cmp.b
#$20,dl
bne
mouslop2
move.w
d2,newx
*
store mouse coordinates
move.w
d3,newy
jsr
saveit
*
store in array
283
ST 3D Graphics
Abacus Software
move.w
newx,d2
* draw line from (n-1) n'th point
move.w
newy,d3
move.w
altx,a2
move. w
alty,a3
jsr
drawl
move.w
newx,d2
move.w
newy,d3
jsr
markit
* and mark point with marker
add. 1
#1,adressx
* increment counter
move.1
adressx,d7
cmp. 1
maxpoint,d7
* and compare with maximum point count
bne
mousl
* if not equal, continue
move.1
adressx,dO
move.w
dO,rlnumpt
* Number of points input
rts
mousend: move.w
d2,newx
move.w
d3,newy
move.w
altx,a2
move.w
alty,a3
jsr
markit
jsr
drawl
* draw last line
jsr
wait
* and wait for keypress
jsr
saveit
add. 1
#1,adressx
* also add last point
move. 1
adressx, dO
move.w
dO,rlnumpt
* now store total number of points
rts
* finally back to caller
***********************************************************************
* Wait for mouse input, returns also on keyboard input *
***********************************************************************
mouspos: move.w #28,contrl * Mouse input, the desired coordinates
move.w #1,contrl+2 * where the mouse should appear,
move.w #0,contrl+6 * are passed in
284
Abacus Software
ST 3D Graphics
move. w
grhandle,contrl+12
move . w
d2,ptsin
*
D2 ,
and D3
move. w
d3,ptsin+2
jsr
vdi
move.w
intout,dl
*
the
result - coordinates
move. w
ptsout,d2
*
are
also returned in D2 and
move . w
ptsout+2,d3
*
D3
rts
* Set the polymarker type *
marktype: move.w
move. w
move. w
move.w
move.w
jsr
rts
#18,contrl
#0,contrl+2
#1,contrl+6
grhandle,contrl+12
dO,intin
vdi
* determines the appearance of
* the polymarker, desired
* type is passed in DO
* Set a polymarker, number in contrl+2 *
markit:
move. w
#7,contrl
move. w
#1,contrl+2 *
Number of
points.
move.w
#0,contrl+6 *
case
only
one
move.w
grhandle,contrl+12
move. w
d2,ptsin
move.w
d3,ptsin+2
movem.1
d0-d2/a0-a2,-(a7)
jsr
vdi *
draw
marker
movem.1
(a7)+,dO-d2/aO-a2
rts
285
ST 3D Graphics
Abacus Software
A**********************************************************************
* Set input mode
***********************************************************************
setmode:
move. w
#33,contrl * Set input mode
move.w
#0,contrl+2
move.w
#2,contrl+6
move.w
grhandle,contrl+12
move.w
dO,intin
move.w
dl,intin+2 * Parameters in DO
jsr
vdi
rts
* Store coordinates entered in point array *
sub.w
picturex,d2
* Pass mouse coordinates to
move. w
d2,(a4)+
* rotation line array, with
sub.w
picturey,d3
* adaptation to coordinate system
neg.w
d3
move.w
d3, (a5) +
move.w
#0, (a6) +
rts
Abacus Software
ST 3D Graphics
**********************************************************************
* Display and describe the same screen page *
**********************************************************************
move.w
#-l,-(a7)
* Display of Display Page,
move.1
physbase.
“ (a7)
* where drawing is made
move.1
physbase.
- (a7)
move.w
#5,-(a7)
trap
#14
add. 1
#12,a7
rts
* Change the mouse form *
setform:
move. w
#78, contrl
* Set mouse
form
move.w
#1, contrl+2
move.w
#1,contrl+4
* passed in
DO
move.w
#1,contrl+6
move.w
#0,contrl+8
move.w
dO,intin
jsr
aes
rts
desired shape
***********************************************************************
* Drawing a coordinate system for mouse input *
***********************************************************************
jsr
clwork.
* draw coordinate
move.w
#0, d2
* for mouse input
move.w
picturey,d3
move.w
picturex,d5
lsl. w
#1, d5
move.w
d5,a2
287
ST 3D Graphics
Abacus Software
move.w
d3,a3
jsr
drawl
move.w
picturex,d2
move.w
#0, d3
move. w
d2,a2
move.w
picturey,d5
lsl. w
#1, d5
move.w
d5,a3
jsr
drawl
rts
******************************************************************
* remove all characters present in the keyboard buffer *
******************************************************************
clearbuf:
clearnd:
move - w
#$b,-(a7)
*
Gemdos fnct. character in Buffer ?
trap
#1
addq.1
#2,a7
tst. w
dO
*
if yes, get character
beq
clearnd
*
if no, terminate
move.w
#1,-U7>
*
Gemdos fnct. CONIN
trap
#1
*
repeat, until all characters
addq.1
#2,a7
*
are removed from the buffer
bra
clearbuf
rts
* Definition of a custom mouse form - Data in mousforl *
mousform:
move.1
#15,dO
* permits the definition of
move.1
Imousforl,al
* new mouse form, data is
move.w
#111,contrl
* in mousforl
move.w
#0,contrl+2
move.w
#37,contrl+6
move.w
grhandle,contrl+12
move.w
#8,intin
move.w
#8,intin+2
288
Abacus Software
ST 3D Graphics
move.w
#1,intin+4
move.w
#0,intin+6
move.w
#1,intin+8
move.1
tintin+10,a5
move.1
(al)+,(a5)+
dbra
dO,forlop
jsr
vdi
rts
.even
* Beginning of the Variable area *
* *
* Data area for the rotation body *
.bss
numro:
.ds. w
1
numpt:
.ds. w
1
rotxdat:
.ds.l
1
rotydat:
.ds.l
1
rotzdat:
.ds.l
1
rotdatx:
.ds.l
1
rotdaty:
.ds.l
1
rotdatz:
.ds.l
1
rlnumline
.ds. w
1
rlnummark
.ds. w
1
rlnumsurf
. ds. w
1
plusagle:
.ds. w
1
rldatx:
. ds. w
1600
rldaty:
• ds. w
1600
rldatz:
. ds . w
1600
289
ST 3D Graphics
Abacus Software
rllin: .ds.l 3200 * 4-Bytes for every line e
rlplane: .ds.l 6600
• data
rlxdat: .dc.w 0,40,50,50,20,30,20,30,70,80,80,0
.dc.w 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
rlydat: .dc.w 100,100,80,60,40,30,30,-70,-80,-90,-100,-100
.dc.w 0,0,0,0,0,0, 0,0, 0,0, 0,0,0,0, 0,0, 0,0, 0,0
rlzdat: .dc.w 0,0,0,0,0,0,0,0,0,0,0,0
.dc.w 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
rlnumpt: .dc.w 12
rlnumro: .dc.w 8
* *
* *
* Definition of the house *
* *
************************************************************************
.data
housdatx: .dc.w -30,30,30,-30,30,-30,-30,30,0,0,-10,-10,10,10
.dc.w 30,30,30,30,30,30,30,30,30,30,30,30
housdaty: .dc.w 30,30,-30,-30,30,30,-30,-30,70,70,-30,0,0,-30
.dc.w 20,20,0,0,20,20,0,0
.dc.w -10,-10,-30,-30
housdatz: .dc.w 60 , 60 , 60 , 60 ,- 60 ,- 60 ,- 60 ,- 60 , 60 ,- 60 , 60 , 60 , 60,60
.dc.w 40,10,10,40,-10,-40,-40,-10
.dc.w 0,-20,-20,0
290
Abacus Software
ST 3D Graphics
houslin: .dc.w 1,2,2,3,3,4,4,1,2,5,5,8,8,3,8,7,7,6,6,5,6,1,7,4
.dc.w 9,10,1,9,9,2,5,10,6,10,11,12,12,13,13,14
.dc.w 15,16,16,17,17,18,18,15,19,20,20,21,21,22,22,19
.dc.w 23,24,24,25,25,26,26,23
***********************************************************************
* Here is the definition of the surfaces belonging to the house *
***********************************************************************
houspla: .dc.w 4 , 1 , 2 , 2 , 3 , 3 ,4,4,1,4,2,5,5,8,8,3,3,2
.dc.w 4,5,6,6,7,7,8,8,5,4,7,6,6,1,1,4,4,7
.dc.w 4,4,3,3,8,8,7,7,4,4,2,9,9,10,10,5,5,2
.dc.w 4,10,9, 9,1,1, 6,6,10,3,1, 9, 9, 2,2,1
.dc.w 3,5,10,10,6,6,5,4,11,12,12,13,13,14,14,11
.dc.w 4 ,15,16,16,17,17,18,18,15,4,19,20,20,21,21,22,22,19
.dc.w 4,23,24,24,25,25,26,26,23
hnummark.: .dc.w 26 * Number of corner points in the house
hnumline: .dc.w 32 * Number of Lines in the House
hnumsurf: .dc.w 13 * Number of Surfaces in the House
hxangle: .dc.w 0 * Rotation angle of House about the X-axis
hyangle: .dc.w 0 * " " " Y-axis
hzangle: .dc.w 0 * ” " " Z-Axis
xwplus:
.dc.w
0
*
Angle increment about
the
X-axis
ywplus:
.dc.w
0
★
Angle increment about
the
Y-axis
zwplus:
.dc.w
0
★
Angle increment about
the
Z-axis
picturex:
.dc.w
0
★
Definition of zero point
of screen
picturey:
.dc.w
0
★
entered by getreso
rotdpx: .dc.w 0
rotdpy: .dc.w 0
rotdpz: .dc.w 0
291
ST 3D Graphics
Abacus Software
rlzl:
. dc. w
0
normz:
. dc. w
1500
.bss
plusrot:
. ds. 1
1
first:
. ds. w
1
second:
• ds. w
1
deltal:
.ds. w
1
worldpla:
•—i
w
T3
1
. data
plag:
• dc.b
1
.even
.bss
diffz:
• ds .w
1
dx:
.ds. w
1
dy:
.ds. w
1
dz:
• ds. w
1
wrldx:
.ds. w
1600
* World coordinate array
wrldy:
. ds. w
1600
wrldz:
. ds. w
1600
viewx:
. ds. w
1600
* View coordinate array
viewy:
. ds. w
1600
viewz:
. ds. w
1600
screenx:
. ds. W
1600
* Screen coordinate array
screeny:
.ds .w
1600
292
Abacus Software
ST 3D Graphics
wlinxy:
.ds. 1
3200
* Line array
wplane:
.ds. 1
6600
* Surface array
vplane:
.ds. 1
6600
* Surface array of visible surface
space:
.ds. 1
2
pladress:
.ds. 1
3000
* Surface array
surfcount
: .ds.w
1
numsurf:
.ds .w
1
zcount:
.ds. 1
1
* Sum of all Z-coord.
zsurf:
.ds.w
1
* Individual Z-coord. of surface
sx:
.ds.w
1
sy:
.ds.w
1
sz:
.ds.w
1
px:
.ds.w
1
py:
.ds.w
1
pz:
.ds.w
1
rx:
.ds.w
1
ry:
• ds.w
1
rz:
• ds.w
1
qx:
.ds.w
1
qy:
.ds. w
1
qz:
.ds.w
1
kx:
.ds.w
1
ky:
.ds.w
1
kz :
.ds.w
1
293
ST 3D Graphics
Abacus Software
Hr ************** + ********************★***
.data
• even
maxpoint:
.dc. 1
25
mousx:
.dc.w
0
mousy:
• dc.w
0
mousbut:
.dc.w
0
kybdstat:
.dc.w
0
altx:
.dc.w
0
alty:
.dc.w
0
newx:
.dc.w
0
newy:
.dc.w
0
adressx:
.dc. 1
1
.data
prox:
.dc.w
0
* Coordinates of the projections
proy:
.dc.w
0
* center on the positive
proz:
.dc.w
1500
* Z-axis
.data
of fx:
.dc.w
0
* Transformation during rotation
of fy:
.dc.w
0
* to point (offx,offy,offz]
of f z:
• dc.w
0
xoffs:
• dc.w
0
* Inverse transformation to point
yoffs:
• dc.w
0
* [xoff,yoffs,zoffs]
zoffs:
.dc.w
0
textl:
.dc.b
27,'Y',56,61,' <c)
Uwe Braun 1985 ',0
text2:
.dc .b
27,'E',27,'p',13,'
Input ',' 4-Pts ' , '
.dc.b
' 12-Pts '
.dc.b
' 18-Pts 24-Pts
45-Pts 60-Pts
.dc.b
' POS ',' Quit'
,27,'q',0
text3:
.dc.b
13, 10,' F-l
F-2 F-3
.dc.b
' F-5 F-6
F-7 F-8
.dc.b
' F-9 F-10
' t 13,0
-Pts
F-4
294
Abacus Software
ST 3D Graphics
mousforl: .dc.w
.dc.w
.dc.w
• dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
mousdatl: .dc.w
.dc.w
.dc.w
• dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
.dc.w
• dc.w
.dc.w
.bss
loopc: .ds.l
. end
%11111111111111U
%iiiiiiiimniii
%ooooooinuooooo
%0000110000010000
%0001001111001000
%0010010000100100
%0100100000010010
%1001000000010100
%1001000000010100
%1000100000100101
%0100011111001001
%0010000000010010
%0001111111100101
%0011111111111001
%0111111111111111
%1111111111111110
%0000000000000000
1
295
ST 3D Graphics
Abacus Software
4.5.1 Description of the new subroutines:
menu: Display a small menu and wait for a function key
to be pressed. (F10 returns to Desktop
immediately)
testhide: Test if H or P key pressed, branch accordingly to
dohide or dopaint.
dohide: Calculate visible surfaces and draw. Then check if
filling is required, if not, wait for <Retum>.
dopaint: Fill all surfaces of rotation body and wait for
<Retum>.
paint a 11: Enter all surfaces of rotation body into surf addr
array, sort and fill.
inpmous: Enter up to 25 points (maxpoint) with the left
mouse button. These points are entered through
save it into the point array of the rotation body.
Enough space must be reserved in the point array
by entering zeros here. For entering fewer than
maxpoint points end input with the right mouse
button.
mouspos: Wait for mouse input, also returns after keypress.
Therefore it checks to see which event occured.
This GEM function must be called twice for
unknown reasons in order to wait once for an input.
marktype: Determines the appearance of the marker set by
function polymarker.
markit: Call the function polymarker to set a marker.
setmode: Set input mode.
save it: Stores the coordinates entered with the mouse in
the point array of the definition line for the rotation
body.
296
Abacus Software
ST 3D Graphics
saveit:
switch:
setf orm:
coord:
mousform:
Stores the coordinates entered with the mouse in
the point array of the definition line for the rotation
body.
Switches the logical page to the displayed page so
that the page being drawn is the page being
displayed. Otherwise the filling will not be seen
and the hardcopy with <Altemate> and <Help>
will not function either.
Change mouse form.
Draw a coordinate system.
Permits the definition of a user-defined mouse
form whose data follows after mousforl. This
new mouse form appears after F9 is pressed and
looks like a snail. You can change the data in the
program according to your own taste.
297
ST 3D Graphics
Abacus Software
4.6 Handling several objects
All subroutines discussed up to now really allow the simultaneous display
of several objects. The only changes required are limited to the
construction of an object definition block for each object, as well as an
exchange of the makewrld routine. Let us consider the concrete
example of the house from hidel. s and the changes that would be
required, to construct a world system with two houses using the existing
definition.
The most promising approach appears to be to copy all of the house
definitions (housdatx, houslin, houspla, etc.) into the
corresponding arrays of the world system several times. The point
coordinate arrays housdatx etc. do not present problems. They can be
simply appended to the world system. A world system containing two
houses would contain 52 points. More difficult is the creation of the
world line array since the line definition of the individual objects, here
the two houses, always starts at point offset one; the first line of every
object starts at point 1 and runs to point 2 for the houses. If the world
point array is extended by another house, it becomes apparent that the
first line of the second house starts at point 27 of the world point array
and runs to point 28, since the first 26 points belong to the first object
The necessary procedure is simple: when constructing the line array from
the individual object line arrays, add the total number of points in the first
object to each line definition of the second object. Analagously, with
three objects the sum of the points of the first two objects is added to the
line definitions of the third object during construction of the world line
array.
The principle of the construction of the world line array is also used
during construction of the world surface array, for example the first
surface definition of the second house within the world surface array:
4,27,28,28,29,29,30,30,27
Furthermore, the total number of all points, lines and surfaces must be
calculated and recorded.
If we start with a realistic world description, the positions of the objects
in this world system can change continuously-recall the airplane and the
tanker truck from Section 4.1. As a consequence of this, it is necessary to
298
Abacus Software
ST 3D Graphics
objects belonging to it. The recreation is limited to the coordinate arrays
however, since only they change. The line and surface arrays are not
affected by the position change. The line and surface world arrays are
created only once at the beginning of the program. The coordinate array
is created twice in every main loop pass.
Now to the object definition block, which contains all the information
describing the individual object. The idea was to extend the available
world system by one object through addition of the definition block to the
existing blocks and incrementing the "object counter." Here for
clarification is an object definition block in which N is replaced with the
index of the current object:
objectN:
objNxda: .dc.l Address of the X-coordinate
array of the obj.
objNyda: .dc.l Address of the Y-coordinate
array of the obj.
objNzda: .dc.l Address of the Z-coordinate
array of the obj.
objNlin: .dc.l Address of the object line
array
objNpla: .dc.l Address of the object surface
array
objmrk: .dc.w Number of points in this
object
objNali: .dc.w Number of lines in this
object
objpln: .dc.w Number of surfaces on this
object
objNxO: .dc.w X-position of object in world
system
objNyO: .dc.w Y-position of object in world
system
objNzO: .dc.w Z-position of object in world
system
objNxw: .dc.w Rotation angle of obj. about
X-axis
objNyw: .dc.w Rotation angle about Y-axis
objNzw: .dc.w Rotation angle aboutZ-axis
299
ST 3D Graphics
Abacus Software
The angles and also the position in the world system relate to the
"rotationally neutral” point of the current object, the origin of the object
definition coordinate system. As a whole, the block consists of 38 bytes,
but can easily be extended with additional information, such as scale
factors, etc. If two identical objects are to be created, you write two
object definition blocks this is important since the creation routine finds
the next block using the distance of 38 bytes between two blocks. Since
two identical objects are to be created, the addresses for the two blocks
are the same and only the position of the objects and perhaps the rotation
angles differ. After the definition has been completed, the total number of
objects, in this case two, is placed in the variable numob j: and now the
total world system can be generated with a single subroutine call.
Examine the definition blocks in the following listing of multil. s, in
which four identical objects are already created through concatenation of
four object definition blocks. Naturally, you are not limited to the
creation of identical objects. You can define a new object, such as a
church, and enter its definition array address and desired position into an
object block. Three houses and your church will be displayed.
Description of the new subroutines in multil. s:
The main loop is easily changed. Here the total number of the desired
objects, four, is passed and the new subroutines new_wrld and
new_mark are called.
new_wrld: The one-time call to the subroutine first creates the
entire world system consisting of coordinate, line
and surface arrays with corresponding parameter
passing of the lines created, etc. Furthermore, the
world parameters are passed to the variables of the
link file. This assignment was previously
performed by subroutine wrldset.
new_mark: Change the position of an object in the world
system this subroutine recreates the total
coordinate system with the aid of the modified
parameters and at the same time passes the world
parameters to the variables of the link file.
300
Abacus Software
ST 3D Graphics
new_it:, surf_lin:, surf_arr:
These three subroutines are called by new_wrld
and new , mark and handle the actual creation of
the world system from the individual object
definitions.
change: Change the object parameters of the individual
objects. For simplification, modification is passed
to all four objects.
General comments on the program:
Beside being able to display multiple objects, this program offers another
novelty: two successive transformations of the same object. First, the four
objects are "set" into the world system with new_mark: after they have
first been rotated about three axes. After all objects have been ‘’rotated" in
the world system you can, through control with the keyboard, rotate the
entire system consisting of the four houses around a point in the world
system, or move the projection plane similar to previous programs. The
four houses of the system rotate around different axes of their
"rotationally neutral” points at various places in the world system. The
display on the screen occurs after the removal of the hidden lines with the
familiar subroutine hide it:, which is used on the complete world array
so that the four houses are not created through mirroring or something
similar, but the hidden surfaces of all four objects are calculated in real¬
time. The hide it algorithm of this program does not recognize
covering by other visible surfaces so that a house covered by other houses
will be drawn.
Control keys are again the cursor, help and undo keys, as well as the / * -
+ keys on the keypad.
The speed is quite impressive. One enhancement, besides the addition of
user-defined objects, is the ability to change an object’s parameters in the
subroutine change: by keyboard input, for example, and to change the
position of single objects in the system.
301
ST 3D Graphics
Abacus Software
* multil.s 22.2.1986 *
* Multiple objects, four houses *
* with hidden line algorithm *
* *
. globl
.globl
.globl
.globl
.globl
.globl
.text
main,xoffs,yoffs,zoffs,offx,offy,offz
viewx,viewy,viewz
wlinxy,mouse off,setrotdp,inp_chan,pointrot
wrldx,wrldy,wrldz,gnummark,gnumline,gnumpla
viewx,viewy,viewz,wplane
new it,new_wrld,obj2mrk, obj2pln
* The program starts here—called by link-file *
main:
mainl:
jsr
apinit
*
Announce program
jsr
grafhand
*
Get screen handle
jsr
openwork
*
Announce screen
jsr
mouse off
*
Switch off mouse
jsr
getreso
*
Screen resolution
jsr
setcocli
*
set Cohen-Sutherland clip.
jsr
clearbuf
move.w
#4,gnumobj
*
announce four objects
jsr
pageup
jsr
clwork
*
Screen resolution
jsr
setrotdp
*
initialize obs. ref. point.
jsr
pagedown
*
Display logical screen page
jsr
clwork
jsr
inp_chan
*
Input and change world parameters
jsr
change
*
Change object parameters
jsr
new_wrld
★
create lines and surfaces
302
Abacus Software
ST 3D Graphics
mainlopl:
jsr
pointrot
*
rotate around observ. ref. point
jsr
pers
*
Perspective transformation
jsr
hideit
*
calculate hidden surface
jsr
surfdraw
★
and draw
jsr
pageup
★
Display physical screenpage
jsr
change
*
change object parameters and
jsr
new mark
★
calculate new coordinates
jsr
inp chan
*
Input new parameters
jsr
clwork
*
erase page not displayed
jsr
pointrot
★
Rotate around rot. ref. point
jsr
pers
★
Transform new points
jsr
hideit
*
Calculate hidden surfaces
jsr
surfdraw
*
and draw them
jsr
pagedown
*
Display this logical page
jsr
change
*
Change object parameters
jsr
new mark
★
Calculate new point coordinates
jsr
inp chan
*
Input and change parameters
jsr
clwork
*
erase physical page
jmp
mainlopl
★
to main loop
move.1
physbase.
logbase
jsr
pageup
*
switch to normal display page
rts
*
back to link file, and end
A**********************************************************************
* Create the point coordinates of the world array with the *
* information from the object parameter block (objectl) *
***********************************************************************
new mark:
move. w
#0,offx
move.w
>■
4-1
4-1
0
o
move. w
#0,offz
jsr
new it
move.1
#viewx,pointx
move.1
#viewy,pointy
move.1
#viewz,pointz
move . 1
#wrldx,datx
move. 1
#wrldy,daty
mo ve. 1
#wrldz,datz
move.1
#wlinxy,linxy
303
ST 3D Graphics
Abacus Software
move.w gnummark, nummark
move.w gnumline,numline
move.w gnumpla,numsurf
rts
* Change the object parameter, in this case the rotation angle
* in the object parameter block, which is then taken into account *
* when calculating point coordinates with rnew_mark
**********************************************************************
change :
changwl:
move. w
objlyw,dO
add. w
#4, dO
cmp.w
#360,dO
bit
changwl
sub.w
#360,dO
move.w
dO,objlyw
move.w
dO,obj2xw
move.w
dO,obj3zw
move.w
dO,obj4xw
move.w
dO,obj4yw
move.w
rts
dO,obj4zw
***********************************************************************
* Set all world parameters for the link file variables and
* create the point, line, and surface arrays of the world system
***********************************************************************
new wrld:
move. w
#0, dO
move.w
dO,offx
move.w
dO,offy
move.w
dO,offz
move.w
proz,zobs
move.w
#0,dist
move.1
iscreenx,xplot
move.1
#screeny,yplot
move.w
picturex,xO
move.w
picturey,yO
* Location of projection plane
* Address of screen array
* Screen center
Abacus Software
ST 3D Graphics
jsr
new it
*
Pass coordinates
jsr
surf lin
*
Pass lines
jsr
surf arr
*
Pass surfaces of
move. w
gnummark,nummark
*
all objects to world system
move.w
gnumline,numline
*
Total number of corners, lines
move.w
gnumpla,numsurf
★
and surfaces of world system
move.1
#wrldx,datx
*
Pass parameters of world system to
move.1
#wrldy,daty
*
link file variables
move.1
#wrldz,datz
move. 1
#viewx,pointx
move.1
#viewy,pointy
move.1
#viewz,pointz
move.1
#wlinxy,linxy
rts
* Subroutine for creating the world system coordinate array *
•ft**********************************************************************
new it:
new_lopl:
move.1
#0,mark_it
*
Pointer in wrldx,wrldy,wrldz
move.w
gnumobj,dO
*
Total number of objects
ext .1
dO
*
as counter
subq.1
#1, dO
*
Address of first object parameter
move.1
#objectl, aO
*
block after AO.
move.1
(aO),datx
*
Objectldatx, daty,datz, pass
move.1
4(aO),daty
*
addresses of point array of
move.1
8(aO),datz
*
first object.
move.1
mark_it,d7
*
Offset in point array
lsl.l
#1, d7
*
times two bytes per entry
move.1
d7,d6
add. 1
#wrldx,d7
*
equals offset in world system array
move.1
d7,pointx
*
Target of transmission
move.1
d6,d7
add. 1
#wrldy,d7
move.1
d7,pointy
add. 1
twrldz,d6
move.1
d6,pointz
* Array of world coordinates
move.w
20(aO),nummark
* Number of corners in the object
move.w
2 6{aO),xoffs
* X-offset
move.w
28(aO),yoffs
* Y-offset in the world system
move.w
30(aO),zoffs
* Z-offset
305
ST 3D Graphics
Abacus Software
move.w
32(aO),xangle
*
Rotation angle of object around
move.w
34(aO),yangle
*
the three coordinate axes
move.w
36 (aO),zangle
movem.1
d0-d7/a0-a6, -(a?)
* Save registers
jsr
matinit
*
Initialize rotation matrix
jsr
zrotate
*
rotate first about the Z-axis, then
jsr
yrotate
*
around Y-axis, and finally
jsr
xrotate
*
around the X-axis (matrix).
jsr
rotate
*
rotate in world coordinate system
movem.1
<a7)+,d0-d7/a0-a6
move.w
20 (aO),d7
★
Number of corners in the object
ext. 1
d7
add. 1
d7,mark_it
★
as offset in point array for
add. 1
#38,aO
*
the next object
dbra
dO, new_lopl
*
repeat, until all objects
move.1
mark_it,d7
★
have been pased. After end in
move.w
d7,gnummark
*
mark it the total number of
rts
it
points in the world system
***********************************************************************
* Pass all lines to world system, one-time call at *
* program start since nothing changes in the lines
***********************************************************************
surf lin:
move.w
gnumobj,dO
ext. 1
d°
subq.1
#1, dO
move.1
#objectl,aO
move. 1
#0,linpntr
move. w
#0,mark it
sflnlopl:
move. 1
linpntr,d7
lsl.l
#2,d7
move. 1
d7,d6
add. 1
twlinxy,d7
move.1
d7, a2
move. 1
12(aO),al
move.w
22(aO),dl
ext. 1
dl
lsl.l
#1, dl
subq.1
#1, dl
* Total of all objects
* as counter
* Address of first Object par. blk.
* Pointer to line array
* Pointer to point array
* Line pointer times four,
* one lines requires four
* bytes.
* Start address of line array, add
* to line pointer
* Address of line array of object
* Number of lines in this object
* Number of lines times two equals
* Loop counter for word transmission
306
Abacus Software
ST 3D Graphics
sflnlop2: move.w
(al)+ ,d7
*
first point of first line
add. w
mark it,d7
*
add the offsets of current
move . w
d7,(a2)+
*
objects, and store in world line;
dbra
dl,sflnlop2
*
array, until all lines of this
*
object
move.w
20(aO),d7
*
Number of corners of last object
add. w
d7,mark it
*
add to corner pointer
move. w
22 (aO) ,d7
★
Number of lines
ext. 1
d7
add. 1
d7,linpntr
*
Total number of lines
add. 1
#38,aO
*
Object offset, distance to next
dbra
dO,sflnlopl
★
object. When all objects are
*
completed
move. 1
linpntr,d7
★
then store total number of lines
move.w
d7,gnumline
*
in the world system and
rts
*
back
s surface
array of the
r*********************'
move.w
#0,mark_it
move.1
#0,plapntr
move.w
#0,gnumpla
move.w
gnumobj,dO
ext. 1
dO
subq.1
#l,d0
move.1
#objectl,aO
move.1
plapntr,d7
add. 1
#wplane,d7
move.1
d7,a2
move. w
24 (aO),dl
ext .1
dl
subq.1
#1, dl
move.1
16 (aO),al
move.w
(al),d2
ext. 1
d2
lsl.l
#1, d2
* Create the array of surfaces
* Counter of surfaces
* Number of objects
* as loop counter
* Address of first object param. blk
* Pointer to surface array
* World surface array
* Number of surfaces on this object
* as loop counter
* Address of surface array of the object
* Number of lines of this surface
* times four (one line = four bytes)
307
ST 3D Graphics
Abacus Software
move.1
d2,d6
lsl.l
#l,d6
* complete the mult. by 4
addq.1
#2,d6
* plus 2 bytes for number of lines
subq.1
#l,d2
* counter
add. 1
d6,plapntr
move. w
(al)+, (a2) +
* Number of lines in this surface
sfarlop3: move.w
<al)+ , d7
* From the object surface array
add. w
mark_it,d7
* Add point offset of the object
move.w
d7, <a2) +
* to world surface array
dbra
d2,sfarlop3
* until all lines of this surface
dbra
dl,sfarlop2
* until all surfaces on this object
move.w
20 (aO),d7
* Number of corners
add.w
d7,mark it
* add to point offset
move.w
24 (aO),d7
add.w
d7,gnumpla
* add to total number
add. 1
#38,aO
* Object offset to next object
dbra
dO, sfarlopl
* until all objects of the world
rts
* and return
* Input and change
parameters
********************************************************************
inp_chan: jsr
inkey
* Read keyboard, key code in
cmp.b
#'D',dO
bne
inpwait
jsr
scrdmp
* make hardcopy
inpwait: swap
dO
* DO , test if
cmp.b
#$4d,d0
* Cursor-right
bne
inpl
addq.w
#1,ywplus
* if yes, add one to Y-angle
bra
inpendl
* increment and continue
inpl: cmp.b
#$4b,dO
* Cursor-left, if yes then
bne
inp2
* subtract one from Y-angle
subq.w
#1,ywplus
* increment
bra
inpendl
308
Abacus Software
ST 3D Graphics
inp2:
cmp .b
#$50,dO
* Cursor-down, if yes then
bne
inp3
addq. w
#1,xwplus
* add one to X-angle increment
bra
inpendl
inp3 :
cmp .b
#$48,dO
* Cursor-up
bne
inp3a
subq.w
#1,xwplus
* subtract one
bra
inpendl
inp3a:
cmp .b
#$61,d0
* Undo key
bne
inp3b
subq.w
#1,zwplus
bra
inpendl
inp3b:
cmp.b
#$62,dO
* Help key
bne
inp4
addq ..w
#1,zwplus
bra
inpendl
inp4 :
cmp.b
#$4e,dO
* plus key on the keypad
bne
inp5
* if yes, subtract 25 from position
sub. w
#25,dist
* projection plane (Z-coordinate)
bra
inpendl
inp5:
cmp.b
#$4a,d0
* minus key on the keypad
bne
inp6
*
add. w
#25,dist
* if yes, add 25
bra
inpendl
inp6:
cmp.b
#$66,dO
* times key on keypad
bne
inp7
* if yes, then subtract 15 from the
★
rotation
sub.w
#15,rotdpz
* point Z-coordinate
bra
inpendl
* Make change
inp7:
cmp.b
#$65,dO
* Division key on keypad
bne
inp8
add. w
#15,rotdpz
* add 15
bra
inpendl
inp8:
309
ST 3D Graphics
Abacus Software
inplO:
crop -b
#$44,dO
* F10 pressed ?
bne
inpendl
addq.1
#4, a 7
* if yes, jump to
bra
mainend
* new input
inpendl:
move. w
hyangle,dl
* Rotation angle about Y-axis
add. w
ywplus,dl
* add increment
cmp. w
#360,dl
* when larger than 360, then subtract
bge
inpend2
cmp. w
#-360,dl
* if smaller then 360, then
ble
inpend3
* add 360
bra
inpend4
inpend2:
sub. w
#360,dl
bra
inpend4
inpend3:
add.w
#360,dl
inpend4:
move.w
dl,hyangle
move.w
hxangle,dl
* proceed in the same manner with
add.w
xwplus,dl
* Rotation angle about the X-axis
cmp. w
#360,dl
bge
inpend5
cmp.w
#-360,dl
ble
inpend6
bra
inpendl
inpend5:
sub. w
#360,dl
bra
inpend7
inpend6:
add.w
#360,dl
inpend7 :
move.w
dl,hxangle
move.w
hzangle,dl
add.w
zwplus, dl
cmp.w
#360,dl
bge
inpend8
cmp.w
#-360,dl
ble
inpend9
bra
inpendlO
inpend8 :
sub. w
#360,dl
bra
inpendlO
inpend9:
add.w
#360,dl
310
Abacus Software
ST 3D Graphics
inpendlO: move.w dl,hzangle
rts
******************************************************************
* Determine the current screen resolution *
******************************************************************
getreso:
move. w
#4,-(a7)
. trap
#14
addq.1
#2,a7
cmp. w
#2, dO
bne
getrl
move.w
#320, picturex
* Monochrome monitor
move.w
#200,picturey
bra
getrend
getrl:
cmp. w
#l,d0
bne
getr2
move.w
#320,picturex
* medium resolution (640*200)
move.w
#100,picturey
bra
getrend
getr2:
move.w
#160,picturex
* low resolution (320*200)
move.w
#100,picturey
getrend:
rts
* Hardcopy of screen, called by inp_chan *
scrdmp:
move.w
trap
addq.1
jsr
rts
#20,- (a7)
#14
#2,a7
clearbuf
311
ST 3D Graphics
Abacus Software
A**********************************************************************
* Initialize the rotation reference point to [0,0,0] *
***********************************************************************
setrotdp: move.w
#0, dl
* set the initial rotation
move.w
dl,rotdpx
* reference point
move.w
dl,rotdpy
move. w
dl,rotdpz
move.w
#Q,hyangle
* initial rotation angle
move. w
#0,hzangle
move.w
#0,hxangle
move.w
#0,ywplus
move. w
#0,xwplus
move.w
#0,zwplus
rts
*******************************************************************,
* Rotation around
the rot. ref.
point around all three axes
*******************************************************************>
pointrot: move.w
hxangle,xangle * rotate the world around
move.w
hyangle,yangle
move.w
hzangle,zangle
move.w
rotdpx,dO
* rotation ref. point
move.w
rotdpy,dl
move.w
rotdpz,d2
move.w
dO,xoffs
* add for inverse transformation
move.w
dl,yoffs
move.w
d2,zoffs
neg .w
dO
neg. w
dl
neg. w
d2
move.w
dO,offx
* subtract for transformation
move.w
dl,offy
move.w
d2,offz
jsr
matinit
* matrix initialization
jsr
zrotate
* rotate 'matrix' aboutZ-axis
jsr
yrotate
* rotate 'matrix' about Y-axis
jsr
xrotate
* then rotate around X-axis
jsr
rotate
* Multiply points with the matrix
312
Abacus Software
ST 3D Graphics
*********************************************************************
* Set the limits of screen window for the Cohen-Sutherland *
* clip algorithm built into the draw-line algorithm *
* The limits can be freely selected by the user, which makes the *
* draw-line algorithm very flexible. *
*********************************************************************
setcocli: move.w #0,clipxule
move.w # 0,c1ipyule
move.w picturex,dl
lsl.w #1,dl
subq.w #l,dl
move.w dl,clipxlri
move.w picturey,dl
lsl.w #1,dl
subq.w #l,dl
move.w dl,clipylri
rts
* Entry of visible Surfaces into the vplane array *
*********************************************************************
hideit:
move.w numsurf,dO * Number of surfaces as counter
ext.1 dO
subq.l #l,dO
move.1 #viewx,al * The point coordinates are stored
move.l #viewy,a2 * here
move.l #viewz,a3
move.l #wplane,aC * here is the information for
move.l #vplane,a5 * every surface
move.w #0,surfcount * counts the known visible surfaces.
visible: move.w (aO),dl * start with first surface. Number of
ext.l dl * points on this surface in Dl.
move.w 2(a0),d2 * Offset of first point on this surface
move.w 4(a0),d3 * Offset of second point
move.w 8(a0),d4 * Offset of third point
subq.w #l,d2 * subtract one for access to point array
subq.w #1,d3 * from current point offset.
313
ST 3D Graphics
Abacus Software
doitl:
subq.w
#l,d4
lsl. w
#l,d2
★
continue to multiply with two
lsl. w
#l,d3
lsl. w
#1, d4
*
and then access current
move.w
(al,d3.w),dS
★
point coordinates
cmp.w
<al,d4.w),d6
*
Comparison recognizes two points
bne
doitl
*
with matching coordinates, which can
move.w
(a2,d3.w),d6
*
occur during construction of rotation
cmp. w
(a2,d4.w),d6
*
bodies. When two identical points
bne
doitl
*
are found, the program
move.w
(a3,d4.w),d6
*
selects a third point for determination
cmp. w
(a3,d3.w),d6
*
of the two vectors.
bne
doitl
move.w
12(aO),d4
subq.w
#l,d4
lsl. w
#1, d4
move.w
(al,d3.w),d5
* here the two vectors which lie in the
move.w
d5, kx
* surface plane are determined through
sub. w
(al,d2.w),d5
* subtraction of the coordinates from
move.w
d5,px
* two points of the surface
move.w
(a2,d3.w),d5
move.w
d5,ky
* The direction coordinates of the
sub.w
U2,d2.w) ,d5
* vectors are stored in the variables
move.w
d5,py
* qx,qy,qz and px,py,pz.
move.w
(a3,d3.w),d5
move.w
d5, kz
sub. w
(a3,d2.w),d5
move.w
d5, pz
move.w
(al,d4.w),d5
* Calculate vector Q
sub. w
(al,d2.w),d5
move.w
(a2,d4.w) ,d6
sub. w
(a2,d2.w),d6
move.w
(a3,d4.w),d7
sub. w
(a3,d2.w),d7
move. w
d5,dl
* qx
move . w
d6,d2
* qy
move. w
d7,d3
* qz
314
Abacus Software
ST 3D Graphics
vector
* the
sightl
mu Is
py,d3
* Calculate of the cross product
mu Is
pz, d2
* of the vector perpendicular
sub. w
d2,d3
* to the current surface
move.w
d3, rx
mu Is
pz, dl
mu Is
px,d7
sub. w
d7, dl
* the direction coordinates of the
move.w
dl, ry
* standing vertically to the surface
mu Is
px, d6
* are temporarily stored in rx,ry,rz
mu Is
py,d5
sub. w
d5,d6
move.w
d6, rz
move.w
prox,dl
*
The projection center serves as
the comparison
sub. w
kx,dl
*
point for the visibility of a surface.
move.w
proy,d2
*
which is acceptable for the viewing
sub. w
ky,d2
*
situation chosen here. One can also
move.w
proz,d3
*
use the observation ref. point as
sub. w
kz, d3
*
comparison point.
mu Is
rx, dl
*
Now follows the comparison of vector
muls
ry, d2
*
R and the vector from one point of the
mu Is
rz,d3
*
surface to the projection center
add.l
dl, d2
*
by creation of the scalar product
add.l
d2,d3
*
of the two vectors.
bmi
dosight
surface is visible, otherwise continue with next surface.
move.w (aO),dl * Number of lines of the surface
ext.l dl
lsl.l #2,dl * Number of lines times 4 = space for Lines
addq.l #2,dl * plus 2 bytes for the number of lines.
add.l dl,aO * add to surface array for access
: dbra dO,visible * to next surface. If all surfaces
bra hideend * are completed, then end.
ST 3D Graphics
Abacus Software
dosight:
move. w
ext .1
(aO),dl *
dl *
move.1
lsl.l
move. 1
addq.1
dl, d2
#1,dl *
aO, a4
#2,a4 *
sight3:
move.w
(aO)+,(a5)+
dbra
dl,sight3
addq. w
bra
#1,surfcount
sight1
hideend:
rts
Number of lines in this surface,
multiplied by two equals the
number of words to be passed
Access to first line of the Surface
* Pass the number of the lines
* and the individual lines
* the number of surfaces plus
* one, and work on next one
*********************************************************************
* Draw surfaces entered in vplane *
**********************************************************************
surfdraw:
move.1
move.1
* draw surfaces with the count
xplot,a4 * of surfaces passed in surfcount
yplot,a5
move. 1
move.w
ext .1
subq.1
bmi
surflopl: move.w
ext. 1
subq.1
#vplane,a6 * Description in array at address
surfcount,dO * vplane, was entered by routine hideit
dO
#1, dO
surfend
(a6)+,dl
dl
#l,dl
* if no surface was entered in array,
* then end.
* Number of lines on this surface
* as counter of lines to be drawn.
surflop2: move.1
(a6)+,d5
* first line of this surface
subq.w #l,d5
lsl.w #1,d5
move.w 0 (a4,d5.w),d2
move.w 0 (a5,d5.w),d3
swap d5
* Access to screen array, which contains
* display coordinates of the
* points.
* extract points, pass from
* the routine.
316
Abacus Software
ST 3D Graphics
subq. w
#l,d5
lsl. w
#l,d5
move. w
0 (a4, d5 . w) , a2
*
second point belonging to the the line
move. w
0 (a5, d5 . w) , a3
jsr
drawl
*
draw line, until all lines of this
dbra
dl,surflop2
*
surface have been drawn and repeat
dbra
dO,surflopl
*
until all surface have been drawn.
rt s
*
finally return.
* Display and description of the same screen page *
switch:
move.w
#-l,-<a7)
move. 1
physbase,- (a7)
move.1
physbase,- (a7)
move. w
#5,-<a7)
trap
#14
add. 1
#12,a7
rts
* show display page in which
* drawing is being made
******************************************************************
* remove all characters present in the keyboard buffer *
clearbuf:
clearnd:
move.w
#$b,-(a7)
★
Gemdos function, character in buffer
trap
#1
addq.1
#2,a7
tst. w
dO
*
if yes, get character
beq
clearnd
★
if no, terminate
move. w
#1,-(a7)
★
Gemdos function CONIN
trap
#1
★
repeat until all characters have
addq.1
#2,a7
★
been removed from the buffer
bra
clearbuf
rts
. even
317
ST 3D Graphics
Abacus Software
• data
housdatx:
.dc. w
-30,30,30,-30,30,-30,-30,30,0,0,-10,-10,10,10
.dc.w
30,30,30,30,30,30,30,30,30,30,30,30
housdaty:
.dc. w
30,30,-30,-30,30,30,-30,-30,70,70,-30,0,0,-30
.dc.w
20,20,0,0,20,20,0,0
.dc.w
-10,-10,-30,-30
housdatz:
.dc.w
60, 60, 60, 60,-60,-60,-60,-60, 60,-60,60,60, 60, 60
• dc.w
40,10,10,40,-10,-40,-40,-10
.dc.w
0,-20,-20,0
houslin:
.dc.w
1,2,2,3, 3, 4,4,1,2,5,5, 8, 8,3, 8, 7,7,6, 6, 5, 6,1,7,4
.dc.w
9,10,1,9,9,2,5,10,6,10,11,12,12,13,13,14
.dc.w
15, 16, 16, 17, 17,18,18, 15, 19,20,20,21,21,22,22,19
.dc.w
23,24,24,25,25,26,26,23
318
Abacus Software
ST 3D Graphics
* here is the definition of the surfaces belonging to the house *
houspla: .dc.w 4,1, 2,2,3,3, 4,4,1, 4,2,5, 5,8, 8,3, 3,2
.dc.w 4,5,6,6,7,7,8,8,5,4,7,6,6,1,1,4,4,7
.dc.w 4,4,3,3,8,8,7,7,4,4,2,9,9,10,10,5,5,2
.dc.w 4,10,9,9,1,1,6,6,10,3,1,9,9,2,2,1
.dc.w 3,5,10,10,6,6,5,4,11,12,12,13,13,14,14,11
.dc.w 4,15,16,16,17,17,18,18,15,4,19,20,20,21,21,22,22,19
.dc.w 4,23,24,24,25,25,26,26,23
hnummark:
.dc.w
26
*
Number
of corner
■ points of the
house
hnumline:
.dc.w
32
■*
Number
of lines
of the
house
hnumpla:
.dc.w
13
★
Number
of surfaces of
the house
hxangle:
.dc.w
0
* Rotation angle
of house about
X-axis
hyangle:
.dc.w
0
*
H
II
II
Y-axis
hzangle:
.dc.w
0
*
11
II
M
Z-axis
xwplus:
.dc.w
0
*
Angle
increment
about
X-axis
ywplus:
• dc.w
0
*
Angle
increment
about
Y-axis
zwplus:
.dc.w
0
*
Angle
increment
about
Z-axis
picturex:
.dc.w
0
*
Definition of zero point on the
screen
picturey:
.dc.w
0
★
entered by getreso
rotdpx:
.dc.w
0
rotdpy:
.dc.w
0
rotdpz:
. dc. w
0
rlzl: .dc.w 0
normz: .dc.w 1500
.bss
319
ST 3D Graphics
Abacus Software
plusrot:
.ds. 1
1
first:
. ds. w
1
second:
.ds. w
1
deltal:
.ds. w
1
worldpla:
.ds. 1
1
.data
plag:
.dc .b
1
. even
.bss
diffz:
• ds .w
1
dx:
.ds .w
1
dy:
.ds .w
1
dz:
.ds. w
1
wrldx:
.ds. w
1600
* world coordinate array
wrldy:
• ds .w
1600
wrldz:
.ds .w
1600
viewx:
• ds. w
1600
* view coordinate array
viewy:
.ds .w
1600
viewz:
• ds. w
1600
screenx:
.ds. w
1600
* screen soordinate array
screeny:
.ds. w
1600
wlinxy:
.ds. 1
3200
* line array
wplane:
.ds. 1
6600
* surface array
vplane:
.ds. 1
6600
* surface array
320
Abacus Software
ST 3D Graphics
space:
. ds. 1
2
pladress:
.ds. 1
3000 *
surfcount:
. ds. w
1
numsurf:
. ds. w
1
zcount:
. ds. 1
1 *
zsurf:
. ds . w
1 *
*****************************
.data
gnumobj:
.dc.w
2
gnummark:
. dc. w
0
gnumline:
.dc.w
0
gnumpla:
.dc.w
0
mark_it:
.dc. 1
0
linpntr:
.dc. 1
0
plapntr:
.dc. 1
0
objectl:
objlxda:
.dc. 1
housdatx
objlyda:
.dc. 1
housdaty
objlzda:
.dc. 1
housdatz
objllin:
.dc. 1
houslin
objlpla:
.dc. 1
houspla
objlmrk:
.dc.w
26
objlali:
.dc.w
32
objlpln:
.dc.w
13
objlxO:
.dc.w
150
objlyO:
.dc.w
100
objIzO:
.dc.w
0
objlxw:
.dc.w
20
objlyw:
.dc.w
0
objlzw:
.dc.w
0
object2:
obj2xda:
• dc. 1
housdatx
obj2yda:
.dc. 1
housdaty
obj2zda:
.dc. 1
housdatz
* surface array
321
ST 3D Graphics Abacus Software
obj21in: .dc.1 houslin
obj2pla: .dc.l houspla
obj2mrk: .dc.w 26
obj2ali: .dc.w 32
obj2pln: .dc.w 13
obj2x0: .dc.w -150
obj2y0: .dc.w 100
obj2z0: .dc.w 0
obj2xw: .dc.w 0
obj2yw: .dc.w 20
obj2zw: .dc.w 0
object3:
obj3xda:
.dc.l
housdatx
obj3yda:
.dc.l
housdaty
obj3zda:
.dc.l
housdatz
obj31in:
.dc.l
houslin
obj3pla:
.dc.l
houspla
obj3mrk:
.dc.w
26
obj3ali:
.dc.w
32
obj3pln:
.dc.w
13
obj3x0:
.dc.w
-150
obj3y0:
.dc.w
-100
obj 3z0:
• dc.w
0
obj3xw:
.dc.w
0
obj3yw:
.dc.w
20
obj3zw:
.dc.w
0
object4 :
obj4xda:
.dc.l
housdatx
obj4yda:
.dc.l
housdaty
obj4zda:
.dc.l
housdatz
obj41in:
.dc.l
houslin
obj4pla:
.dc.l
houspla
obj4mrk:
.dc.w
26
obj4ali:
.dc.w
32
obj4pln:
.dc.w
13
obj 4x0:
.dc.w
150
obj4y0:
.dc.w
-100
obj4z0:
.dc.w
0
322
Abacus Software
ST 3D Graphics
obj 4xw:
.dc. w
0
obj 4yw:
.dc.w
0
obj4zw:
.dc. w
0
.bss
sx:
.ds.w
1
sy:
.ds.w
1
sz:
.ds.w
1
px:
.ds.w
1
py:
.ds.w
1
pz:
.ds.w
1
rx:
.ds.w
1
ry:
.ds.w
1
rz:
-ds.w
1
qx:
.ds.w
1
qy:
.ds.w
1
qz:
.ds.w
1
kx:
.ds.w
1
ky:
.ds.w
1
kz:
• ds.w
1
**********************
.data
• even
maxpoint:
.dc. 1
25
mousx:
.dc.w
0
mousy:
.dc. w
0
mousbut:
.dc. w
0
kybdstat:
.dc.w
0
altx:
.dc.w
0
alty:
.dc.w
0
newx:
.dc.w
0
newy:
.dc.w
0
323
ST 3D Graphics
Abacus Software
addrssx:
.dc. 1
1
.data
prox:
.dc.w
0
* Coordinates of Projection
proy:
. dc. w
0
* Center on the positive
proz:
• dc.w
1500
* Z-axis
• data
of fx:
.dc. w
0
* transformation during Rotation
of fy:
. dc. w
0
* to Point [offx,offy,offz]
of f z:
.dc.w
0
xoffs:
.dc. w
0
* Inverse transformation to point
yoffs:
.dc.w
0
* [xoff,yoffs,zoffs]
zoffs:
.dc.w
0
.bss
loopc:
.ds. 1
1
.end
Desk File View Options
A:\
D:\
F:\3DU0RK.DIRS
253882 butes used 1
1442236 butes used In 129 itens, ■ 333956 bytes used In
X PRINTERS
8 TUTORIAL
C
COMV
NLlfl
OUTPUT
SPLIT
STANDARD
TEXTPRO
TUTORIAL
XTTUTORI
FRY
TTP
PRO
PRG
TTP
PRT
PRG
TXT
TOC
BASIC
BASIC
BASIC
BASIC1
PRG
RSC
MRK
BAR
138344 11-21
4648 11-21
346 11-26
14801 11-26
OPEN APPLICATION
Nane: BATCH .TTP
Paraneters; .
asllnk grllnkl miltll)-
I OK 1 I Cancel
HOUSE1 PRG
HOUSE1 S
MAIK1 PRG
KAIN1 S
HAIN1C0 PRG
MAIN1C0 S
MEKU1 PRG
HENU1
MULTI1
MULTI1
PAINT1
PRINT1
ROTATE1 PRG
R0TATE1 S
S
PRG
S
PRG
S
1 0 a? a?
min \trrm ■n'v.-r rrrwt j-amattfil jS33HEflB33i
■BSffiSMI
324
Abacus Software
ST 3D Graphics
5. Suggestions for additional development
One application of this program module for manipulating three-
dimensional objects that will occur to almost everyone is a flight
simulator. The last program can in fact be used as a basis for a flight
simulator. We are missing the description of the position of the airplane
in the world system as well as a modified point rot routine. The
modified point rot routine, after rotation around the reference point,
should not transform all of the world coordinates back to the old
coordinate origin, which occurred in the old point rot routine by
adding the reference point coordinates after the rotation. Furthermore,
houses do not change position in the world system of a flight simulator
and for an airport other structures must be developed (hangar, tower). In
addition, fields, forests, and landing strips can be simulated with simple
rectangular surfaces.
The position of the airplane, or to be exact, the center of its cockpit
windshield, in the the reference point in the world system for all
transformations to follow, especially that of the creation of the view
system. For simulation of airplane movement, the reference point must be
manipulated with keyboard input. This input must affect both the point
coordinates as well as the orientation of the plane in space. The
orientation of the airplane in space- is described with the three angles
(hxangle,hyangle,hzangle) so that even adventurous flight
situations (spins) can be simulated. For adjustment of the world system to
the airplane system the following operations are required:
1. Move the coordinate origin of the world system to the
cockpit center by subtracting the cockpit windshield
center-coordinates from all point coordinates.
2. Rotate of the displaced world system about the three
rotation angles which describe the position of the airplane
in relation to its three axes.
327
ST 3D Graphics
Abacus Software
3. Remove hidden surfaces with hideit, noting that the
reference point for the calculation of the vector S through
point [0,0,0], the cockpit center-point (coordinate origin of
the view system) is chosen and not the projection center,
which of course can also be freely selected in this
observation model. From the endpoint of vector S the
direct result: all objects outside the cockpit window are, if
they satisfy the criteria for visibility, visible.
4. Projection on the screen through the perspective transform
routine.
After the observed world is displayed, the parameters such as the position
of the airplane in the world system or the position of other objects in the
world system, such as a second airplane, can be changed. Now the
procedure described above is called again and this cycle repeated
continually.
328
Abacus Software
ST 3D Graphics
5.1 Light and Shadow
To enhance the program module to correctly define a light source, as in
section 2.8, it is necessary to have the vectors L, i.e. the vector, which
points from each surface to the observation reference point as well as the
vector N, which points from the light source to the current surface, as unit
vectors of length one. One should divide the vector coo rdinates (x, y, z)
by the root of the sum of its squares V(x2+y2 + z 2). Furthermore, the
data structure of the objects must be changed since you want to shade the
surfaces according to the light intensity and not according to their Z-
coordinates. It is possible to enter the intensity of every surface in the
extended surfaddr array and give each surface an individual shading
pattern, either through comparison of the light source vectors or
completely at random.
329
ST 3D Graphics
Abacus Software
5.2 Animated Cartoons
In principle even this application has already been realized in program
multi. s. You simply create more objects in a world system and then
changes their position and place in the system continuously. The world
line and surface arrays, as we have seen, need be created only once while
the coordinate array is created with every pass through the main loop.
After the line surface array has been constructed, you have free choice in
the number of displayed objects, i.e. you can define, for example, ten
objects through object definition blocks but at the creation of the comers
you could only actually create and display. One possible application is
moving text where the letters are three dimensional objects. You could
have several letters "fly" together from various directions and assemble
them on the screen into a word. The complete word could then be rotated
around some point. The individual letters could even be constructed with
the mouse.
330
Abacus Software
ST 3D Graphics
Appendix A: Number systems
Every number, in any number system, is represented by a sequence of
digits. This sequence may be interrupted by a decimal point. We can
write the following for the digit sequence:
(...a4a3a2aiao.a-ia-2a-3a-4.")b =
+ a4*b4 + a3*b3 + a2*b2 + ai*bl + ao*bO + a-i*b _ l + ...
Here the coefficients a-4 to a4 represent the individual digits of the
number and b is the number base. Here is an example of the most
commonly used number system, the decimal system:
(3423.87)10 =
3*103 + 4*102 + 2*101 3*100 + 8*10-1 + 7*10-2 =
3000 + 400 + 20 + 3 + 0.8 + 0.07 = 3423.87
Two number systems often encountered, in computer programming, are
the binary (base 2) and the hexadecimal systems (base 16). Binary uses
only the two numbers 0 and 1 as digits. An example:
1110010010010= 1*212+1*211+1*210+1*27+1*24+1*21=
4096 + 2048 + 1024 + 128 + 16 + 2 = 7314
Numbers in the hexadecimal system with base 16 are generally indicated
by a leading dollar sign ($). For representation of numbers in this format,
the standard ten digits from 0 to 9 are not enough. For this reason the first
six characters of the alphabet are added (A through F). A has the value of
10, and F means 15. It is especially easy to convert between binary and
hexadecimal. Four binary digits (4 bits) are grouped together, starting
from the decimal point, to form one hexadecimal digit.
333
ST 3D Graphics
Abacus Software
The unwieldy binary number 1110010010010 becomes the hexadecimal
number $1C92. The conversion into the Decimal system is done in the
same manner as for the binary system. $1C92 means therefore:
1*163 + 12*162 + 9*161 + 2*160 =
1*4096 + 12*256 + 9*16 + 2*1 = 7314
334
Abacus Software
ST 3D Graphics
Appendix B: Analytical geometry of planes and space
The cartesian coordinate system is defined as a system of perpendicular
lines in which the horizontal line is designated as the X-axis (abscissa)
and the line perpendicular to it is called the Y-axis (ordinate). The
intersection of the two lines is the origin of the system. Now all points
within the system can be defined unambiguously by specifying their
coordinate values (x,y).
A line in such a system is defined by two points which belong on the line.
All points on the line can be ascertained with the following equation.
y-yi
x-xl
y2 : yl
x2-xl
for (x2-xl) <> 0
In this two point format, the expression (y2-yl)/(x2-xl) gives the slope m
of the straight line, which simultaneously represents the tangent of the
angle between the line and the X-axis (phi).
335
ST 3D Graphics
Abacus Software
y2-yi
x2-xt
Figure B.l: Line in the plane
With the definition of the slope m as well as the axis intersection a, the
intersection of the line with the Y-axis, we get what is called the normal
form of the straight line equation.
y = m*x + a
With this equation you can calculate all points on the line by introducing
various X values into the above equation, knowing the slope m and axis
intersection a.
For the middle-point of a straight line which connects two points (PI,
P2), we can easily calculate the coordinates of this segment:
Xm =
xl+x2
"T*
Ym =
yl+y2
2
336
Abacus Software
ST 3D Graphics
The two equations above are used in the Cohen-Sutherland clipping
algorithm.
The geometry of a plane is just a special case of the geometry of space
and therefore the same laws apply to a straight line in space as to a
straight line in a plane, i.e. two points are also sufficient to define a point
in space. One difference from the plane is the Z-axis which, if one leaves
the X and Y axis unchanged, can point in different directions. Depending
on the direction used, this system is called a right-hand or left-hand
system. They differ therefore only in the orientation of the Z-axis.
Figure B.2
An easy way to distinguish between the right- and left-hand systems as
well as all operations within the system is possible with the aid of a screw
(imagine simply a normal screw inside the system). The screw transfers a
rotating motion into a movement along the rotation axis and there are
basically two types of screws: those with left-handed threads and those
with right-handed threads. For a complete system description, we still
need to know how positive angles are measured and for equalization of
both coordinate systems the following definition is agreed upon:
337
ST 3D Graphics
Abacus Software
Rotation about the: positive angle is measured:
Z-axis from +X to +Y axis
Y-axis from +Z to +X axis
X-axis from +Y to +Z axis
With the aid of this definition we can say for the system and the screw: If
a screw is placed in such a system (in the direction of a coordinate axis)
and the screw is turned about a positive angle (see above definition), then
the screw moves in the direction of a positive coordinate axis. You can
determine the position axis of a coordinate system through the definition
of the positive angle as well as the selection of the screw, or you can
recognize the type of an existing coordinate system. As an explanation, in
a right-hand system the right-handed screw moves in the direction of a
positive coordinate axis when rotated about a positive angle. On the other
hand, a left handed screw in a left-hand system rotated about a positive
angle will also move in the direction of positive coordinate axis. Since in
our country, screws with right-handed threads are most common, we shall
follow the positive rotations of a right-handed screw in a right-hand
system.
338
Abacus Software
ST 3D Graphics
Figure B.3: Screws in a right-hand system
339
ST 3D Graphics
Abacus Software
Two points in space or in a plane are sufficient to describe a line. Under
consideration of Z-coordinates the following relationships hold:
y-yl = y2-y 1 z-zl _ z2-zl
x-xl x2-xl x-xl x2-xl
Using a parameter u, which can assume real values between -infinity and
+infinity, all points on a line running through points Pl[xl,yl,zl]
and P2 [x2, y2, z2 ] can be determined. For individual coordinates the
values are:
x = (x2-xl) * u + xl
y = (y2-yi) * u + yl
z = (z2-zl) * u + zl
If we use only u real numbers between 0 and 1, all points on the line
between PI and P2 can be calculated. The line would not run beyond PI
and P2, but would be cut off at the two points. From the lines we get a
vector, which has a definite direction in space. In our example it points
from PI to P2.
A vector is a directional line, the connecting line between two points in a
coordinate system. The coordinates of the vector are calculated by
subtracting the point coordinates. The vector is therefore indicated by the
vector coordinates and its direction. The direction is shown in the
illustration by an arrow. A vector can be moved along its axis without
consequences for the total system, since only the length and direction are
of significance.
340
Abacus Software
ST 3D Graphics
The vector S in Figure 6.3.4 is given by its vector coordinates
S [sx, sy, sz] = [x2-xl,y2-yl,z2-zl] and its value, the length
of the distance S, can be determined as follows:
Value S = |S| = V (sx 2 + sy2 + sz2)
A unit vector is a vector whose value is one. If you want to generate a
unit vector to a given vector S, a vector which points in the same
direction as S but has a value of one, the vector coordinates of the unit
vector are I [ix,iy,iz]:
sx sy . sz
ix =—— iv — iz =rr:—
Dividing the individual vector coordinates of vector S [sx,sy,sz]by
the length of vector S results in the vector coordinates of the unit vector.
341
ST 3D Graphics
Abacus Software
Various operations can be performed on the vectors and those important
for our purposes are:
1 . The scalar product (A-B)
2. The cross product (AXB)
B.l Scalar Product
The scalar product is the sum of the products of the individual vector
coordinates and is important to determine angles (phi) between two
vectors (A,B).
A-B = ax*bx+ay*by+az*bz = | A | *| B |*cos(phi)
A-B =V ( (ax 2 +ay 2 +az 2 ) * (bx 2 +by 2 +bz2) ) *cos (phi)
See also Figure 2.7.5.
B.2 Cross Product
The cross product (AxB), in contrast to the scalar product, is not a real
number but another vector (C). The resultant vector stands perpendicular
to the plane between the vectors A and B and together with them forms a
new coordinate system. The rule of the screw helps us again in the
determining the direction of the resulting vector:
In a right-hand system the result vector (C = [cx,cy,cz]) of the
cross product points in the same direction in which a screw with right-
handed threads would move from A to B when turned. The vectors A, B,
and C form a right-hand system. Similarly for a left-hand system: if one
turns a left-threaded screw from A to B , then C points in the direction in
which^tfie~stxew would move. This connection can be seen easily in
Figure 6.3.5 afad in our program is responsible for the recognition of
visible, surfaces)
Abacus Software
ST 3D Graphics
Figure B.5
To determine the result vector C [cx,cy,cz] one proceeds as follows:
A*B = [ ax*bz-az*by, az*bx-ax*bz, ax*by-ay*bx]
343
ST 3D Graphics
Abacus Software
Appendix C: Matrix calculations
A matrix (m,n) is a square number system consisting of m by n numbers.
an
an
an
... am
a2i
a22
a23
... a 2 n
a3i
a32
a33
... 33n
ami
4m2
Sm3
... amn
aik where i =
1,2..
.m and k =
---- -HIV A ulllVj Uliu U1V VIVUlUiUJ
aik,a 2 ic,.-amk form the kth column of the matrix. If the number of columns
is equal to the number of rows (m=n), A is called a square matrix. A few
rules can be stated for matrix calculation.
1. Matrices are designated with uppercase letters (A-Z). The
individual elements of a matrix carry the corresponding
lower case letter (a-z).
2. The element aik is located in the ith row, kth column of
matrix A. i is the row index and k is the column index.
3. The matrix A(m,n) is of the type (m,n) and is defined as a
two-dimensional matrix with m rows and n columns.
4. Matrices with one row and any number of columns, of the
type (l,n), are called row vectors and those of type (n,l)
are called column vectors.
344
Abacus Software
ST 3D Graphics
C.l Adding matrices
The addition of matrices is defined only for matrices of the same
dimensions. Here is an example with two (3,3) matrices, A with the
elements aik and the matrix B with the elements bik- During addition, the
sum matrix S is created with elements sik- S=A+B.
1 2 3
A= 4 5 6
7 8 9
2
C = A+B = 8
14
1 2 3
B = 4 5 6
7 8 9
4 9
10 12
16 18
The elements of the sum matrix result from: sik = aik + bik for i,k from 1
to 3. The limits of the variables i and k are written in mathematical form:
i,k = 1(1)3. The value in front of the parentheses is the start value, the
value in the parenthesis is the increment and the last number designates
the final value of the variables. In this example, i and k take values of one
through three with an increment of one. These are the numbers 1,2,3.
During matrix addition, one adds the elements which are in the same
place in each matrix, to obtain the elements of the sum matrix S. One
proceeds in the same manner when multiplying of matrix A with a
constant factor f ac. The elements of the product matrix P are calculated
by multiplying each element in A by the factor.
pik = fac * aik i,k= 1(1)3
345
ST 3D Graphics
Abacus Software
C.2 Multiplying Matrices
The multiplication of two matrices A and B is somewhat more complex
than addition and has some limitations. The product of two matrices is
only defined when the number of columns of A matches the number of
rows in B. For two square matrices with i=k=constant, the multiplication
is always defined. The product of two matrices A (ajj) and B (bjk) is
defined as follows: A is a matrix of type (m,l) and B is of type (l,n), then
the product of the matrices A and B is A*B, the result matrix P is (pik),
whose elements are calculated in the following manner:
pik = sum of j=l to 1 over aij*bjk
with i - l(l)m and j = l(l)n.
This connection can be recognized in the following example.
A= 1 2 B= 5 6
3 4 7 8
C = A*B = 1*5 + 2*7 1*6+ 2*8
3*5 + 4*7 3*6 + 4*8
19 22
43 50
The result matrix P therefore contains the same number of lines as the
multiplicand A and the same number of rows as the multiplier B. In
regard to matrix multiplication there is a neutral element, i.e. for every
matrix A there is a matrix N with which A can be multiplied without
changing the original matrix. A*N=A. N is called the unit matrix and the
elements of the diagonal are one. All others have the value zero.
Moreover, the associative and the distributive law are valid during
multiplication.
A*(B*C) = (A*B)*C Associative Law
A*(B+C) = (A*B)+(A*C) Distributive Law
346
Abacus Software
ST 3D Graphics
The commutative law does not hold for matrix multiplication. This means
A*B is not necessarily equal to B*A. The order of the multiplication is
not arbitrary, as you see, and must be observed.
347
ST 3D Graphics
Abacus Software
Appendix D: Bibliography
[1] Foley James D., van Dam A., Fundamentals of Interactive
Computer graphics, Addison Wesley Publishing Company
(1984)
[2] Harrington Steven, Computer Graphics, McGraw-Hill
(1983)
[3] Newman William M., Principles of Interactive Computer
Graphics, McGraw-Hill (1984)
[4] Knuth Donald E., The Art of Computer Programming
Volume 2 Seminumerical Algorithms, Addison-Wesley
Publishing Company (1981)
[5] Kane Gerry, Hawkins Doug, Leventhal Lance, 68000
Assembly Language Programming, McGraw-Hill (1981)
[6] Bruckmann, Englisch, Gerrits, Atari ST Internals, Abacus
Software (1986)
[7] Szczepanowski, Gunther, Atari ST GEM Programmer’s
Reference, Abacus Software (1986)
348
Abacus Software
ST 3D Graphics
INDEX
3-D wire models 4
3-D wire models 56
68000 computer 78
A
Abscissa 335
Apple Macintosh 4
Assembler 88, 89
Associative 346
Axis-symmetrical objects 169
B
BASIC1.S 92
Batch file 90
Binary system.
BIOS 88
C
C programming language 4
CAD systems 3
CAD-CAM 3
Cartesian coordinate system 7, 108,
249, 335
CAT scans 3
Clip algorithm 122
Cohen-Sutherland clipping algorithm
122, 337
Color monitor 219
Column vectors 344
Commodore Amiga 4
Computer animation 3, 56
Computer science 122
Convex polygons 57
Coordinate arrays 299
Coordinate origin 11
Cray II 3,4,56
Cross product 214, 342
D
Data system 117
Decimal system 333, 334
Definition block 298-300
Definition line 169, 189
Desktop 296
Digital Research 88
Direction Binary number 334
Display coordinate system 7
Display of reveral objects 298
Distributive law 346
Draw-line-algorithm 107
E
Extended coordinate system 31
Extended-BIOS 88
G
GEM functions 88
GEM-DOS 88
Global variables 152
GRLINK1.S 123
349
ST 3D Graphics
Abacus Software
H
Harddisk 4
Hexadecimal number 334
Hexadecimal system 333
Hidden lines 4, 248, 249, 301
Hidden surfaces 217, 301
HIDE1.S 198
HOUSE1.S 155
I
Indirect illumination 69
Inverse transformation matrices 41
L
Left coordinate system 30, 34,47,48,
59, 64, 337, 338, 342
Line array 298
Link file 170
Linking programs 89
M-N
Machine language 4, 89
Matrices 344
Matrix addition 345
Matrix multiplication 119,346
MENUl.S 257
Metacombco Editor 107
Monochrome monitors 219
Motorola MC68000 3-4
MULTII.S 302
Normal vector 116
O
Object definition block 299-300
Object definition coordinate system
300
Observation coordinate system 44
Observation direction point (ODP) 43,
44,116,216
Observation reference point (ORP) 43,
44,46
Observation window 43
Observer system 118
Operating system 30, 34,107,218,
248
Ordinate 335
P
PAINT1.S 221
Pascal 4
Perspective transformation 31,119,
122
Picture coordinate system 8-9
Plot-point routine 80
Point coordinate arrays 298
Point light sources 70
Polygon 11
Polymarker 296
Projection 38,51
Projection center 50,116,167, 214
Projection plane 50, 51, 56
R
Real time 3-D graphics 191
Reflection coefficient 69,71
RELMOD 88
350
Abacus Software
ST 3D Graphics
Relocator 89
Right coordinate systems 64,122,214,
337, 338, 342
ROTATEl.S 172
Rotating definition line 170
Rotation 16, 32, 35, 37,41
Rotation body 170,188,296
Rotation line 170,249
Rotation matrices 42,191
Rotation reference point 167
Row vectors 344
S
Scalar product 214, 342
Scaling 10, 12
Scaling matrix 32
Scan line algorithm 56
Screen memory 79
Screen pages 87
Screen switch routine 122
Screen system 118
Shading routine 218,248
Shading surfaces 248
Sine table 78
Size manipulation 120
Slope 81,335,336
Square matrix 344
Straight line equation. 336
Structogram 246
Surface normal vector 216
Surface world arrays 299
T
Unit vector 341
USA Today 3
User-defined objects 301
vectors 38, 340
View coordinate system 8,11,15,43,
116,118,119, 122,214
Visible surfaces 296
W
Window size 165
Wire model mode 249
World array 298, 301
World coordinate system 8, 11,15,44,
109,116,117,119, 120,121,122,165,
188,217,246,298, 299, 300, 301
World parameters 300
World surface array 298
Taylor series 76
Transformations 31,121
Unit matrix 346
351
Optional Diskette
For your convenience, the program listings contained in this book are
available on an SF354 formatted floppy disk. You should order the diskette
if you want to use the programs, but don’t want to type them in from the
listings in the book.
All programs on the diskette have been fully tested. You can change the
programs for your particular needs. The diskette is available for $14.95 plus
$2.00 ($5.00 foreign) for postage and handling.
When ordering, please give your name and shipping address. Enclose a
check, money order or credit card information. Mail your order to:
Abacus Software
P.O. Box 7219
Grand Rapids, MI 49510
Or for fast service, call 1- 616 / 241-5510.
AA Rated Software
Atari and Abacus
A simple-to-use and versatile database
manager. Features help screens;
lightning-fast operation; tailorable
display using multiple fonts;
user-definable edit masks; capacity up
to 64,000 records. Supports multiple
files. RAM-disk support for 1040ST.
Complete search, sort and file
subsetting. Interfaces to TextPro. Easy
printer control. $49.95
ST TextPro
Wordprocessor with professional
features and easy-to-use! Full-screen
editing with mouse or keyboard
shortcuts. High speed input, scrolling
and editing; sideways printing;
multi-column output; flexible printer
installation; automatic index and table
of contents; up to 180 chars/line; 30
definable function keys; metafile
output; much more. $49.95
PaintPro
^ /*V ^
C. Create double¬
sized pictures
Fohrq ^-
PaintPr
>
Multiple J
windows
For creative illustrations on the ST
r
ST PaintPro
A GEM™ among ST drawing programs.
Very friendly, but very powerful design
and painting program, A must for
everyone's artistic or graphics needs.
Use up to three windows. You can
even cut S paste between windows.
Free-form sketching; lines, circles,
ellipses, boxes, text, fill, copy, move,
zoom, spray, paint, erase, undo, help.
Double-sized picture format. $49.95
ST Forth/MT
Powerful, multi-tasking Forth for the ST.
A complete, 32-bit implementation
based on Forth-83 standard. Develop¬
ment aids: full screen editor, monitor,
macro assembler. 1500+ word library.
TOS/LINEA commands. Floating point
and complex arithmetic. $49.95
AssemPro
The complete 68000
assembler development
package for the ST
PCBoard
Designer
Create printed circuit board layouts
^
wuMmfimmWiiWilsmm
Auto routing, component list, pinout list, net list
ST AssemPro PCBoard Designer
Professional developer's package Interactive, computer aided design
includes editor, two-pass interactive package that automates layout of printed
assembler wrth error locator, online help circuit boards. Auto-routing, 45° or
including instruction address mode and 90° traces; two-sided boards; pin-to-pin,
GEM parameter information, pin-to-BUS or BUS-to-BUS. Rubber-
monitor-debugger, disassembler and banding of components during place-
68020 simulator, more. $59.95 ment. Outputs pinout, component and
net list. $395.00
Call now for the name of the dealer nearest you.
Or order directly using your MC, Visa or Amex
card. Add $4.00 per order for shipping. Foreign
orders add $10.00 per item. Call ( 616 ) 241-5510
or write for your free catalog. 30-day money
back software guarantee. Dealers inquires
welcome-over 1400 dealers nationwide.
ST and 1040ST are trademarks ot Atari Corp.
GEM is a trademark at Digital Research Inc.
Abacus
mi
P.0. Box 7219 Dept.NB Grand Rapids, Ml 49510
Phone 616/241 -5510 • Telex 709-101 • Fax 616/241-5021
PRESENTING THE ST
Gives you an indnpth look at
thla • •nietlonal n.w
computsr. Discuss as tha
aichltactura ot tha ST. work¬
ing with GEM. tha mouaa.
operating system, all tha
varioua intarfaoaa, tha 68000
chip and Ita inetructlons.
LOGO 290 pp *16 86
ST Beginner's Oulda
Writtan tor tha Srtthand ST
user Gat a baalc undaratand-
ing ol your ST Explora
LOGO and BASIC from tha
ground up Simpla explan
atlona o' tha hardware and
Intarnal workings o' tha ST
llluatratona. diagrams Gloaa-
ary indax. 200pp $i« 95
ST INTERNALS
Eaaantlal guida to tha Insida
Inlormation ol tha ST
Datailad daacrlptlona ol
■ound and graphica chips.
Intarnal hardware, I/O porta,
ualng GEM Commented
BIOS Hating. An Indiapan
aibla ralaranea lor your ST
library «0pp »'«»
OEM ProgrammeCe Rat.
For aarioua programmara
naadlng detailed nlctmation
on GEM Praaantad in an
oony-to-undoratand format.
All aiamplaa ara In C and
aaaamBty language Covara
VOI and AES function# No
aarioua programar ahould ba
without dIOpp SI 9 99
MACHINE LANGUAGE
Program In tha lastaat lang¬
uaga lor your ATARI ST
Laarn 68000 Meernbly lang.
uaga. ita numbanng ayatam,
uaa cd raglatara. atructura S
Important datarla of Inatruc-
tion aat, and uaa ol intarnal
ayatam routines Gaarad lot
tha ST 280pp *19 95
Fantaatlc collection ol pro-
grama and Into lor tha ST
Complata programa Induda.
euperlast RAM dtak; lima-
aadng prlntar apoolar, color
print hardcopy plotter output
hardcopy, craating access
orlaa Monay aavlng tricks
andtipa 2S0cc *19 99
ST GRAPHICS 4SOUNO
Datailad guida to graphica
and aound on tha ST. 20 6
3D kjnctlon ptottara. Molr*
patlarna, graphic memory
and varioua reaolutiona.
(ractala, recursion waveform
generation Eianpiet written
In C, LOGO. BASIC and
ModMe2 250pp 519 99
ST LOGO OUIOE
Taka contd of your ST by
learning ST LOGO—tha aaay
to uaa. powerful languaga
Topic* Induda 61a handling,
recurslon-HHbert A Sierpinskl
curvaa. 2D and 30 (unction
plots, data atructura. error
handling Helpful guide lor
ST LOGO users. *19.99
ST PEEKS * POKES
Enhance your programa with
tha aiamplaa found within
thla booh Explorea ualng
different languages BASIC.
C. LOGO and machine
languaga. using various
intarlacaa. memory uaaga,
reading and saving horn and
todlak, more 280pp $16 95
BASIC Training Guide
Thorough guida lor Isarning
ST BASIC programming.
Detaled programming funda¬
mentals, commands descilp-
tiona. ST graphics 8 aound.
using GEM in BASIC, lila
management, disk operation.
Tutorial problems give hand*
on experience. 300pp $16 95
BASIC to C
Move up from BASIC to C. If
you're elreedy a BASIC
programmer, you can laarn C
all that much Merer Parallel
examples demoslrate tha
programing techniques and
constucts In both languages.
Variables pointers, arrays,
daU atructura 290pp*19 99
30 GRAPHICS
FANTASTICI Rotate, zoom,
and shade 3D objects. All
programa written In machine
language (or high speed.
Learn the mathematics
behind 3D graphica. Hidden
line removal, shading With
3D pattern maker and
animator. $2* 96
The ATARI logo and ATARI ST era Swdamerkaof Alan Carp.
Abacusiuiiiiiiil Software
P.0. Box 7219 Dept. A9 Grand Rapids, Ml 49510 • Telex 709-101 ■ Phone (616) 241-5510
Optional diskettes are available tor all book titles at $14.95
Call now for the name of your nearest dealer. Or order directly from ABACUS with your MasterCard, VISA, or Amex card. Add
$4.00 per order for postage and handling. Foreign add $10.00 per book. Other software and books coming soon. Call or
write for your free catalog. Dealer inquiries welcome-over 1400 dealers nationwide.
M
n
V
\
1
Q> $&></■>
O ° <
D o / O
3
L> ^ 1 1
T
C> / 150
j
0 / D )
l
0 1 1 0
1
o n\
$
j C?D O
°1
h
I OO)
tp
\ o / -o
( 1
c
l J II
'X
&
! ! ?£>
IX
X3
1 / of
iV
£
j l t V
/f
f
in/
FANTASTIC! Learn how to create impressive and fascinating 3D
graphics on the Atari ST. Covers introductory concepts and
background materials, graphic animation, using the assembler
and much more. Learn real-time animation with dozens of
graphic routines. 3D Graphics is an amazing book for all
programmers interested in advanced level graphics. Some of
the areas covered include:
• 2D & 3D Transformations • Spatial projection
• Hidden lines & surfaces • Screen manipulation
• Data structure for 3D objects • Rotation of objects
• Object animation • Light and shadows
About the author:
Uwe Braun is a member of the Data Becker Product
Development team, based in Duesseldorf, W. Germany. He is a
knowledgeable machine language programmer with extensive
graphics programming experience.
isbn o-nibMai-bn-D
The ATARI logo and ATARI ST are trademarks of Atari Corp.
A Data Becker book published by
a I You Can 0n ImiHHiixil e +
Abacus \mm Software
P.0. Box 7219 Grand Rapids. Ml 49510 - Telex 709-101 - Phone 616/241-5510
Live Music
Archive
Librivox
Free Audio
Metropolitan Museum
Cleveland
Museum of Art
Internet
Arcade
Console Living Room
Open Library
American
Libraries
TV News
Understanding
9/11